From 8f9d933a99aa33c15a2bdfce54005e9d86182054 Mon Sep 17 00:00:00 2001 From: Mihailo Timotic Date: Fri, 18 Jul 2025 20:06:35 +0200 Subject: [PATCH] fix --- .../higher-order-functions.sql.out | 738 ++++++++++++++++ .../nonansi/higher-order-functions.sql.out | 738 ++++++++++++++++ .../inputs/higher-order-functions.sql | 64 +- .../results/higher-order-functions.sql.out | 834 ++++++++++++++++++ .../nonansi/higher-order-functions.sql.out | 834 ++++++++++++++++++ 5 files changed, 3207 insertions(+), 1 deletion(-) diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/higher-order-functions.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/higher-order-functions.sql.out index c06d1e5534aed..ab09f9ee47856 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/higher-order-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/higher-order-functions.sql.out @@ -370,3 +370,741 @@ select aggregate(split('abcdefgh',''), array(array('')), (acc, x) -> array(array -- !query analysis Project [aggregate(split(abcdefgh, , -1), array(array()), lambdafunction(array(array(lambda x#x)), lambda acc#x, lambda x#x, false), lambdafunction(lambda id#x, lambda id#x, false)) AS aggregate(split(abcdefgh, , -1), array(array()), lambdafunction(array(array(namedlambdavariable())), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))#x] +- OneRowRelation + + +-- !query +select aggregate(array(1, 2, 3), 0, 100) as aggregate_int_literal +-- !query analysis +Project [aggregate(array(1, 2, 3), 0, lambdafunction(100, lambda col0#x, lambda col1#x, true), lambdafunction(lambda id#x, lambda id#x, false)) AS aggregate_int_literal#x] ++- OneRowRelation + + +-- !query +select aggregate(array(1, 2, 3), map(), map('result', 999)) as aggregate_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "third", + "requiredType" : "\"MAP\"", + "sqlExpr" : "\"aggregate(array(1, 2, 3), map(), lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 59, + "fragment" : "aggregate(array(1, 2, 3), map(), map('result', 999))" + } ] +} + + +-- !query +select aggregate(array(1, 2, 3), struct('init', 0), struct('final', 999)) as aggregate_struct_literal +-- !query analysis +Project [aggregate(array(1, 2, 3), struct(col1, init, col2, 0), lambdafunction(struct(col1, final, col2, 999), lambda col0#x, lambda col1#x, true), lambdafunction(lambda id#x, lambda id#x, false)) AS aggregate_struct_literal#x] ++- OneRowRelation + + +-- !query +select aggregate(array(1, 2, 3), array(), array('result')) as aggregate_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(result), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "third", + "requiredType" : "\"ARRAY\"", + "sqlExpr" : "\"aggregate(array(1, 2, 3), array(), lambdafunction(array(result), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 58, + "fragment" : "aggregate(array(1, 2, 3), array(), array('result'))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), 1) as array_sort_int_literal +-- !query analysis +Project [array_sort(array(3, 1, 2), lambdafunction(1, lambda col0#x, lambda col1#x, true), false) AS array_sort_int_literal#x] ++- OneRowRelation + + +-- !query +select array_sort(array(3, 1, 2), map('compare', 0)) as array_sort_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"MAP\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(map(compare, 0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 52, + "fragment" : "array_sort(array(3, 1, 2), map('compare', 0))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), struct('result', 0)) as array_sort_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"STRUCT\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(struct(result, 0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 54, + "fragment" : "array_sort(array(3, 1, 2), struct('result', 0))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), array(0)) as array_sort_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"ARRAY\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(array(0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 43, + "fragment" : "array_sort(array(3, 1, 2), array(0))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), 1) as exists_int_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "exists(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select exists(array(1, 2, 3), map('found', true)) as exists_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(found, true), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(map(found, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "exists(array(1, 2, 3), map('found', true))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), struct('exists', true)) as exists_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(exists, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(struct(exists, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 53, + "fragment" : "exists(array(1, 2, 3), struct('exists', true))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), array(true)) as exists_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(array(true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 42, + "fragment" : "exists(array(1, 2, 3), array(true))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), 1) as filter_int_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "filter(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select filter(array(1, 2, 3), map('key', 'value')) as filter_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(key, value), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(map(key, value), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "filter(array(1, 2, 3), map('key', 'value'))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), struct('valid', true)) as filter_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(valid, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(struct(valid, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 52, + "fragment" : "filter(array(1, 2, 3), struct('valid', true))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), array(true, false)) as filter_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true, false), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(array(true, false), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "filter(array(1, 2, 3), array(true, false))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), 1) as forall_int_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "forall(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select forall(array(1, 2, 3), map('all', true)) as forall_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(all, true), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(map(all, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 47, + "fragment" : "forall(array(1, 2, 3), map('all', true))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), struct('all', true)) as forall_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(all, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(struct(all, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "forall(array(1, 2, 3), struct('all', true))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), array(true, true)) as forall_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true, true), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(array(true, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 48, + "fragment" : "forall(array(1, 2, 3), array(true, true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), 1) as map_filter_int_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(1, namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 41, + "fragment" : "map_filter(map('a', 1, 'b', 2), 1)" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), map('keep', true)) as map_filter_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(keep, true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(map(keep, true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 57, + "fragment" : "map_filter(map('a', 1, 'b', 2), map('keep', true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), struct('filter', true)) as map_filter_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(filter, true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(struct(filter, true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 62, + "fragment" : "map_filter(map('a', 1, 'b', 2), struct('filter', true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), array(true)) as map_filter_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(array(true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 51, + "fragment" : "map_filter(map('a', 1, 'b', 2), array(true))" + } ] +} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), 100) as map_zipwith_int_literal +-- !query analysis +Project [map_zip_with(map(a, 1), map(a, 10), lambdafunction(100, lambda col0#x, lambda col1#x, lambda col2#x, true)) AS map_zipwith_int_literal#x] ++- OneRowRelation + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), map('merged', true)) as map_zipwith_map_literal +-- !query analysis +Project [map_zip_with(map(a, 1), map(a, 10), lambdafunction(map(merged, true), lambda col0#x, lambda col1#x, lambda col2#x, true)) AS map_zipwith_map_literal#x] ++- OneRowRelation + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), struct('left', 1, 'right', 10)) as map_zipwith_struct_literal +-- !query analysis +Project [map_zip_with(map(a, 1), map(a, 10), lambdafunction(struct(col1, left, col2, 1, col3, right, col4, 10), lambda col0#x, lambda col1#x, lambda col2#x, true)) AS map_zipwith_struct_literal#x] ++- OneRowRelation + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), array('combined')) as map_zipwith_array_literal +-- !query analysis +Project [map_zip_with(map(a, 1), map(a, 10), lambdafunction(array(combined), lambda col0#x, lambda col1#x, lambda col2#x, true)) AS map_zipwith_array_literal#x] ++- OneRowRelation + + +-- !query +select reduce(array(1, 2, 3), 0, 100) as reduce_int_literal +-- !query analysis +Project [reduce(array(1, 2, 3), 0, lambdafunction(100, lambda col0#x, lambda col1#x, true), lambdafunction(lambda id#x, lambda id#x, false)) AS reduce_int_literal#x] ++- OneRowRelation + + +-- !query +select reduce(array(1, 2, 3), map(), map('result', 999)) as reduce_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "third", + "requiredType" : "\"MAP\"", + "sqlExpr" : "\"reduce(array(1, 2, 3), map(), lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 56, + "fragment" : "reduce(array(1, 2, 3), map(), map('result', 999))" + } ] +} + + +-- !query +select reduce(array(1, 2, 3), struct('init', 0), struct('final', 999)) as reduce_struct_literal +-- !query analysis +Project [reduce(array(1, 2, 3), struct(col1, init, col2, 0), lambdafunction(struct(col1, final, col2, 999), lambda col0#x, lambda col1#x, true), lambdafunction(lambda id#x, lambda id#x, false)) AS reduce_struct_literal#x] ++- OneRowRelation + + +-- !query +select reduce(array(1, 2, 3), array(), array('result')) as reduce_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(result), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "third", + "requiredType" : "\"ARRAY\"", + "sqlExpr" : "\"reduce(array(1, 2, 3), array(), lambdafunction(array(result), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 55, + "fragment" : "reduce(array(1, 2, 3), array(), array('result'))" + } ] +} + + +-- !query +select transform(array(1, 2, 3), 42) as transform_int_literal +-- !query analysis +Project [transform(array(1, 2, 3), lambdafunction(42, lambda col0#x, true)) AS transform_int_literal#x] ++- OneRowRelation + + +-- !query +select transform(array(1, 2, 3), map('key', 'value')) as transform_map_literal +-- !query analysis +Project [transform(array(1, 2, 3), lambdafunction(map(key, value), lambda col0#x, true)) AS transform_map_literal#x] ++- OneRowRelation + + +-- !query +select transform(array(1, 2, 3), struct('id', 99, 'name', 'test')) as transform_struct_literal +-- !query analysis +Project [transform(array(1, 2, 3), lambdafunction(struct(col1, id, col2, 99, col3, name, col4, test), lambda col0#x, true)) AS transform_struct_literal#x] ++- OneRowRelation + + +-- !query +select transform(array(1, 2, 3), array('a', 'b')) as transform_array_literal +-- !query analysis +Project [transform(array(1, 2, 3), lambdafunction(array(a, b), lambda col0#x, true)) AS transform_array_literal#x] ++- OneRowRelation + + +-- !query +select transform_keys(map('a', 1, 'b', 2), 42) as transform_keys_int_literal +-- !query analysis +Project [transform_keys(map(a, 1, b, 2), lambdafunction(42, lambda col0#x, lambda col1#x, true)) AS transform_keys_int_literal#x] ++- OneRowRelation + + +-- !query +select transform_keys(map('a', 1, 'b', 2), map('new', 'key')) as transform_keys_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.INVALID_MAP_KEY_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "keyType" : "\"MAP\"", + "sqlExpr" : "\"transform_keys(map(a, 1, b, 2), lambdafunction(map(new, key), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 61, + "fragment" : "transform_keys(map('a', 1, 'b', 2), map('new', 'key'))" + } ] +} + + +-- !query +select transform_keys(map('a', 1, 'b', 2), struct('key', 'value')) as transform_keys_struct_literal +-- !query analysis +Project [transform_keys(map(a, 1, b, 2), lambdafunction(struct(col1, key, col2, value), lambda col0#x, lambda col1#x, true)) AS transform_keys_struct_literal#x] ++- OneRowRelation + + +-- !query +select transform_keys(map('a', 1, 'b', 2), array('new_key')) as transform_keys_array_literal +-- !query analysis +Project [transform_keys(map(a, 1, b, 2), lambdafunction(array(new_key), lambda col0#x, lambda col1#x, true)) AS transform_keys_array_literal#x] ++- OneRowRelation + + +-- !query +select transform_values(map('a', 1, 'b', 2), 999) as transform_values_int_literal +-- !query analysis +Project [transform_values(map(a, 1, b, 2), lambdafunction(999, lambda col0#x, lambda col1#x, true)) AS transform_values_int_literal#x] ++- OneRowRelation + + +-- !query +select transform_values(map('a', 1, 'b', 2), map('new', 'value')) as transform_values_map_literal +-- !query analysis +Project [transform_values(map(a, 1, b, 2), lambdafunction(map(new, value), lambda col0#x, lambda col1#x, true)) AS transform_values_map_literal#x] ++- OneRowRelation + + +-- !query +select transform_values(map('a', 1, 'b', 2), struct('val', 999)) as transform_values_struct_literal +-- !query analysis +Project [transform_values(map(a, 1, b, 2), lambdafunction(struct(col1, val, col2, 999), lambda col0#x, lambda col1#x, true)) AS transform_values_struct_literal#x] ++- OneRowRelation + + +-- !query +select transform_values(map('a', 1, 'b', 2), array('new_value')) as transform_values_array_literal +-- !query analysis +Project [transform_values(map(a, 1, b, 2), lambdafunction(array(new_value), lambda col0#x, lambda col1#x, true)) AS transform_values_array_literal#x] ++- OneRowRelation + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), 100) as zipwith_int_literal +-- !query analysis +Project [zip_with(array(1, 2, 3), array(4, 5, 6), lambdafunction(100, lambda col0#x, lambda col1#x, true)) AS zipwith_int_literal#x] ++- OneRowRelation + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), map('merged', true)) as zipwith_map_literal +-- !query analysis +Project [zip_with(array(1, 2, 3), array(4, 5, 6), lambdafunction(map(merged, true), lambda col0#x, lambda col1#x, true)) AS zipwith_map_literal#x] ++- OneRowRelation + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), struct('left', 1, 'right', 2)) as zipwith_struct_literal +-- !query analysis +Project [zip_with(array(1, 2, 3), array(4, 5, 6), lambdafunction(struct(col1, left, col2, 1, col3, right, col4, 2), lambda col0#x, lambda col1#x, true)) AS zipwith_struct_literal#x] ++- OneRowRelation + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), array('combined')) as zipwith_array_literal +-- !query analysis +Project [zip_with(array(1, 2, 3), array(4, 5, 6), lambdafunction(array(combined), lambda col0#x, lambda col1#x, true)) AS zipwith_array_literal#x] ++- OneRowRelation diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/higher-order-functions.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/higher-order-functions.sql.out index 1281b19eb2f86..d4717b18bac5b 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/higher-order-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/higher-order-functions.sql.out @@ -370,3 +370,741 @@ select aggregate(split('abcdefgh',''), array(array('')), (acc, x) -> array(array -- !query analysis Project [aggregate(split(abcdefgh, , -1), array(array()), lambdafunction(array(array(lambda x#x)), lambda acc#x, lambda x#x, false), lambdafunction(lambda id#x, lambda id#x, false)) AS aggregate(split(abcdefgh, , -1), array(array()), lambdafunction(array(array(namedlambdavariable())), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))#x] +- OneRowRelation + + +-- !query +select aggregate(array(1, 2, 3), 0, 100) as aggregate_int_literal +-- !query analysis +Project [aggregate(array(1, 2, 3), 0, lambdafunction(100, lambda col0#x, lambda col1#x, true), lambdafunction(lambda id#x, lambda id#x, false)) AS aggregate_int_literal#x] ++- OneRowRelation + + +-- !query +select aggregate(array(1, 2, 3), map(), map('result', 999)) as aggregate_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "third", + "requiredType" : "\"MAP\"", + "sqlExpr" : "\"aggregate(array(1, 2, 3), map(), lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 59, + "fragment" : "aggregate(array(1, 2, 3), map(), map('result', 999))" + } ] +} + + +-- !query +select aggregate(array(1, 2, 3), struct('init', 0), struct('final', 999)) as aggregate_struct_literal +-- !query analysis +Project [aggregate(array(1, 2, 3), struct(col1, init, col2, 0), lambdafunction(struct(col1, final, col2, 999), lambda col0#x, lambda col1#x, true), lambdafunction(lambda id#x, lambda id#x, false)) AS aggregate_struct_literal#x] ++- OneRowRelation + + +-- !query +select aggregate(array(1, 2, 3), array(), array('result')) as aggregate_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(result), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "third", + "requiredType" : "\"ARRAY\"", + "sqlExpr" : "\"aggregate(array(1, 2, 3), array(), lambdafunction(array(result), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 58, + "fragment" : "aggregate(array(1, 2, 3), array(), array('result'))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), 1) as array_sort_int_literal +-- !query analysis +Project [array_sort(array(3, 1, 2), lambdafunction(1, lambda col0#x, lambda col1#x, true), false) AS array_sort_int_literal#x] ++- OneRowRelation + + +-- !query +select array_sort(array(3, 1, 2), map('compare', 0)) as array_sort_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"MAP\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(map(compare, 0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 52, + "fragment" : "array_sort(array(3, 1, 2), map('compare', 0))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), struct('result', 0)) as array_sort_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"STRUCT\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(struct(result, 0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 54, + "fragment" : "array_sort(array(3, 1, 2), struct('result', 0))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), array(0)) as array_sort_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"ARRAY\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(array(0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 43, + "fragment" : "array_sort(array(3, 1, 2), array(0))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), 1) as exists_int_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "exists(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select exists(array(1, 2, 3), map('found', true)) as exists_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(found, true), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(map(found, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "exists(array(1, 2, 3), map('found', true))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), struct('exists', true)) as exists_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(exists, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(struct(exists, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 53, + "fragment" : "exists(array(1, 2, 3), struct('exists', true))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), array(true)) as exists_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(array(true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 42, + "fragment" : "exists(array(1, 2, 3), array(true))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), 1) as filter_int_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "filter(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select filter(array(1, 2, 3), map('key', 'value')) as filter_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(key, value), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(map(key, value), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "filter(array(1, 2, 3), map('key', 'value'))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), struct('valid', true)) as filter_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(valid, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(struct(valid, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 52, + "fragment" : "filter(array(1, 2, 3), struct('valid', true))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), array(true, false)) as filter_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true, false), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(array(true, false), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "filter(array(1, 2, 3), array(true, false))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), 1) as forall_int_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "forall(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select forall(array(1, 2, 3), map('all', true)) as forall_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(all, true), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(map(all, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 47, + "fragment" : "forall(array(1, 2, 3), map('all', true))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), struct('all', true)) as forall_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(all, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(struct(all, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "forall(array(1, 2, 3), struct('all', true))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), array(true, true)) as forall_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true, true), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(array(true, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 48, + "fragment" : "forall(array(1, 2, 3), array(true, true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), 1) as map_filter_int_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(1, namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 41, + "fragment" : "map_filter(map('a', 1, 'b', 2), 1)" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), map('keep', true)) as map_filter_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(keep, true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(map(keep, true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 57, + "fragment" : "map_filter(map('a', 1, 'b', 2), map('keep', true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), struct('filter', true)) as map_filter_struct_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(filter, true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(struct(filter, true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 62, + "fragment" : "map_filter(map('a', 1, 'b', 2), struct('filter', true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), array(true)) as map_filter_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(array(true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 51, + "fragment" : "map_filter(map('a', 1, 'b', 2), array(true))" + } ] +} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), 100) as map_zipwith_int_literal +-- !query analysis +Project [map_zip_with(map(a, 1), map(a, 10), lambdafunction(100, lambda col0#x, lambda col1#x, lambda col2#x, true)) AS map_zipwith_int_literal#x] ++- OneRowRelation + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), map('merged', true)) as map_zipwith_map_literal +-- !query analysis +Project [map_zip_with(map(a, 1), map(a, 10), lambdafunction(map(merged, true), lambda col0#x, lambda col1#x, lambda col2#x, true)) AS map_zipwith_map_literal#x] ++- OneRowRelation + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), struct('left', 1, 'right', 10)) as map_zipwith_struct_literal +-- !query analysis +Project [map_zip_with(map(a, 1), map(a, 10), lambdafunction(struct(col1, left, col2, 1, col3, right, col4, 10), lambda col0#x, lambda col1#x, lambda col2#x, true)) AS map_zipwith_struct_literal#x] ++- OneRowRelation + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), array('combined')) as map_zipwith_array_literal +-- !query analysis +Project [map_zip_with(map(a, 1), map(a, 10), lambdafunction(array(combined), lambda col0#x, lambda col1#x, lambda col2#x, true)) AS map_zipwith_array_literal#x] ++- OneRowRelation + + +-- !query +select reduce(array(1, 2, 3), 0, 100) as reduce_int_literal +-- !query analysis +Project [reduce(array(1, 2, 3), 0, lambdafunction(100, lambda col0#x, lambda col1#x, true), lambdafunction(lambda id#x, lambda id#x, false)) AS reduce_int_literal#x] ++- OneRowRelation + + +-- !query +select reduce(array(1, 2, 3), map(), map('result', 999)) as reduce_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "third", + "requiredType" : "\"MAP\"", + "sqlExpr" : "\"reduce(array(1, 2, 3), map(), lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 56, + "fragment" : "reduce(array(1, 2, 3), map(), map('result', 999))" + } ] +} + + +-- !query +select reduce(array(1, 2, 3), struct('init', 0), struct('final', 999)) as reduce_struct_literal +-- !query analysis +Project [reduce(array(1, 2, 3), struct(col1, init, col2, 0), lambdafunction(struct(col1, final, col2, 999), lambda col0#x, lambda col1#x, true), lambdafunction(lambda id#x, lambda id#x, false)) AS reduce_struct_literal#x] ++- OneRowRelation + + +-- !query +select reduce(array(1, 2, 3), array(), array('result')) as reduce_array_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(result), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "third", + "requiredType" : "\"ARRAY\"", + "sqlExpr" : "\"reduce(array(1, 2, 3), array(), lambdafunction(array(result), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 55, + "fragment" : "reduce(array(1, 2, 3), array(), array('result'))" + } ] +} + + +-- !query +select transform(array(1, 2, 3), 42) as transform_int_literal +-- !query analysis +Project [transform(array(1, 2, 3), lambdafunction(42, lambda col0#x, true)) AS transform_int_literal#x] ++- OneRowRelation + + +-- !query +select transform(array(1, 2, 3), map('key', 'value')) as transform_map_literal +-- !query analysis +Project [transform(array(1, 2, 3), lambdafunction(map(key, value), lambda col0#x, true)) AS transform_map_literal#x] ++- OneRowRelation + + +-- !query +select transform(array(1, 2, 3), struct('id', 99, 'name', 'test')) as transform_struct_literal +-- !query analysis +Project [transform(array(1, 2, 3), lambdafunction(struct(col1, id, col2, 99, col3, name, col4, test), lambda col0#x, true)) AS transform_struct_literal#x] ++- OneRowRelation + + +-- !query +select transform(array(1, 2, 3), array('a', 'b')) as transform_array_literal +-- !query analysis +Project [transform(array(1, 2, 3), lambdafunction(array(a, b), lambda col0#x, true)) AS transform_array_literal#x] ++- OneRowRelation + + +-- !query +select transform_keys(map('a', 1, 'b', 2), 42) as transform_keys_int_literal +-- !query analysis +Project [transform_keys(map(a, 1, b, 2), lambdafunction(42, lambda col0#x, lambda col1#x, true)) AS transform_keys_int_literal#x] ++- OneRowRelation + + +-- !query +select transform_keys(map('a', 1, 'b', 2), map('new', 'key')) as transform_keys_map_literal +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.INVALID_MAP_KEY_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "keyType" : "\"MAP\"", + "sqlExpr" : "\"transform_keys(map(a, 1, b, 2), lambdafunction(map(new, key), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 61, + "fragment" : "transform_keys(map('a', 1, 'b', 2), map('new', 'key'))" + } ] +} + + +-- !query +select transform_keys(map('a', 1, 'b', 2), struct('key', 'value')) as transform_keys_struct_literal +-- !query analysis +Project [transform_keys(map(a, 1, b, 2), lambdafunction(struct(col1, key, col2, value), lambda col0#x, lambda col1#x, true)) AS transform_keys_struct_literal#x] ++- OneRowRelation + + +-- !query +select transform_keys(map('a', 1, 'b', 2), array('new_key')) as transform_keys_array_literal +-- !query analysis +Project [transform_keys(map(a, 1, b, 2), lambdafunction(array(new_key), lambda col0#x, lambda col1#x, true)) AS transform_keys_array_literal#x] ++- OneRowRelation + + +-- !query +select transform_values(map('a', 1, 'b', 2), 999) as transform_values_int_literal +-- !query analysis +Project [transform_values(map(a, 1, b, 2), lambdafunction(999, lambda col0#x, lambda col1#x, true)) AS transform_values_int_literal#x] ++- OneRowRelation + + +-- !query +select transform_values(map('a', 1, 'b', 2), map('new', 'value')) as transform_values_map_literal +-- !query analysis +Project [transform_values(map(a, 1, b, 2), lambdafunction(map(new, value), lambda col0#x, lambda col1#x, true)) AS transform_values_map_literal#x] ++- OneRowRelation + + +-- !query +select transform_values(map('a', 1, 'b', 2), struct('val', 999)) as transform_values_struct_literal +-- !query analysis +Project [transform_values(map(a, 1, b, 2), lambdafunction(struct(col1, val, col2, 999), lambda col0#x, lambda col1#x, true)) AS transform_values_struct_literal#x] ++- OneRowRelation + + +-- !query +select transform_values(map('a', 1, 'b', 2), array('new_value')) as transform_values_array_literal +-- !query analysis +Project [transform_values(map(a, 1, b, 2), lambdafunction(array(new_value), lambda col0#x, lambda col1#x, true)) AS transform_values_array_literal#x] ++- OneRowRelation + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), 100) as zipwith_int_literal +-- !query analysis +Project [zip_with(array(1, 2, 3), array(4, 5, 6), lambdafunction(100, lambda col0#x, lambda col1#x, true)) AS zipwith_int_literal#x] ++- OneRowRelation + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), map('merged', true)) as zipwith_map_literal +-- !query analysis +Project [zip_with(array(1, 2, 3), array(4, 5, 6), lambdafunction(map(merged, true), lambda col0#x, lambda col1#x, true)) AS zipwith_map_literal#x] ++- OneRowRelation + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), struct('left', 1, 'right', 2)) as zipwith_struct_literal +-- !query analysis +Project [zip_with(array(1, 2, 3), array(4, 5, 6), lambdafunction(struct(col1, left, col2, 1, col3, right, col4, 2), lambda col0#x, lambda col1#x, true)) AS zipwith_struct_literal#x] ++- OneRowRelation + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), array('combined')) as zipwith_array_literal +-- !query analysis +Project [zip_with(array(1, 2, 3), array(4, 5, 6), lambdafunction(array(combined), lambda col0#x, lambda col1#x, true)) AS zipwith_array_literal#x] ++- OneRowRelation diff --git a/sql/core/src/test/resources/sql-tests/inputs/higher-order-functions.sql b/sql/core/src/test/resources/sql-tests/inputs/higher-order-functions.sql index 37081de012e98..f1c92327bde3a 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/higher-order-functions.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/higher-order-functions.sql @@ -102,4 +102,66 @@ select transform(ys, all -> all * all) as v from values (array(32, 97)) as t(ys) select transform(ys, (all, i) -> all + i) as v from values (array(32, 97)) as t(ys); -- SPARK-32819: Aggregate on nested string arrays -select aggregate(split('abcdefgh',''), array(array('')), (acc, x) -> array(array(x))); \ No newline at end of file +select aggregate(split('abcdefgh',''), array(array('')), (acc, x) -> array(array(x))); + +-- HigherOrderFunctions without lambda variables + +select aggregate(array(1, 2, 3), 0, 100) as aggregate_int_literal; +select aggregate(array(1, 2, 3), map(), map('result', 999)) as aggregate_map_literal; +select aggregate(array(1, 2, 3), struct('init', 0), struct('final', 999)) as aggregate_struct_literal; +select aggregate(array(1, 2, 3), array(), array('result')) as aggregate_array_literal; + +select array_sort(array(3, 1, 2), 1) as array_sort_int_literal; +select array_sort(array(3, 1, 2), map('compare', 0)) as array_sort_map_literal; +select array_sort(array(3, 1, 2), struct('result', 0)) as array_sort_struct_literal; +select array_sort(array(3, 1, 2), array(0)) as array_sort_array_literal; + +select exists(array(1, 2, 3), 1) as exists_int_literal; +select exists(array(1, 2, 3), map('found', true)) as exists_map_literal; +select exists(array(1, 2, 3), struct('exists', true)) as exists_struct_literal; +select exists(array(1, 2, 3), array(true)) as exists_array_literal; + +select filter(array(1, 2, 3), 1) as filter_int_literal; +select filter(array(1, 2, 3), map('key', 'value')) as filter_map_literal; +select filter(array(1, 2, 3), struct('valid', true)) as filter_struct_literal; +select filter(array(1, 2, 3), array(true, false)) as filter_array_literal; + +select forall(array(1, 2, 3), 1) as forall_int_literal; +select forall(array(1, 2, 3), map('all', true)) as forall_map_literal; +select forall(array(1, 2, 3), struct('all', true)) as forall_struct_literal; +select forall(array(1, 2, 3), array(true, true)) as forall_array_literal; + +select map_filter(map('a', 1, 'b', 2), 1) as map_filter_int_literal; +select map_filter(map('a', 1, 'b', 2), map('keep', true)) as map_filter_map_literal; +select map_filter(map('a', 1, 'b', 2), struct('filter', true)) as map_filter_struct_literal; +select map_filter(map('a', 1, 'b', 2), array(true)) as map_filter_array_literal; + +select map_zip_with(map('a', 1), map('a', 10), 100) as map_zipwith_int_literal; +select map_zip_with(map('a', 1), map('a', 10), map('merged', true)) as map_zipwith_map_literal; +select map_zip_with(map('a', 1), map('a', 10), struct('left', 1, 'right', 10)) as map_zipwith_struct_literal; +select map_zip_with(map('a', 1), map('a', 10), array('combined')) as map_zipwith_array_literal; + +select reduce(array(1, 2, 3), 0, 100) as reduce_int_literal; +select reduce(array(1, 2, 3), map(), map('result', 999)) as reduce_map_literal; +select reduce(array(1, 2, 3), struct('init', 0), struct('final', 999)) as reduce_struct_literal; +select reduce(array(1, 2, 3), array(), array('result')) as reduce_array_literal; + +select transform(array(1, 2, 3), 42) as transform_int_literal; +select transform(array(1, 2, 3), map('key', 'value')) as transform_map_literal; +select transform(array(1, 2, 3), struct('id', 99, 'name', 'test')) as transform_struct_literal; +select transform(array(1, 2, 3), array('a', 'b')) as transform_array_literal; + +select transform_keys(map('a', 1, 'b', 2), 42) as transform_keys_int_literal; +select transform_keys(map('a', 1, 'b', 2), map('new', 'key')) as transform_keys_map_literal; +select transform_keys(map('a', 1, 'b', 2), struct('key', 'value')) as transform_keys_struct_literal; +select transform_keys(map('a', 1, 'b', 2), array('new_key')) as transform_keys_array_literal; + +select transform_values(map('a', 1, 'b', 2), 999) as transform_values_int_literal; +select transform_values(map('a', 1, 'b', 2), map('new', 'value')) as transform_values_map_literal; +select transform_values(map('a', 1, 'b', 2), struct('val', 999)) as transform_values_struct_literal; +select transform_values(map('a', 1, 'b', 2), array('new_value')) as transform_values_array_literal; + +select zip_with(array(1, 2, 3), array(4, 5, 6), 100) as zipwith_int_literal; +select zip_with(array(1, 2, 3), array(4, 5, 6), map('merged', true)) as zipwith_map_literal; +select zip_with(array(1, 2, 3), array(4, 5, 6), struct('left', 1, 'right', 2)) as zipwith_struct_literal; +select zip_with(array(1, 2, 3), array(4, 5, 6), array('combined')) as zipwith_array_literal; diff --git a/sql/core/src/test/resources/sql-tests/results/higher-order-functions.sql.out b/sql/core/src/test/resources/sql-tests/results/higher-order-functions.sql.out index 7bfc35a61e092..b16bbcda2eb5a 100644 --- a/sql/core/src/test/resources/sql-tests/results/higher-order-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/higher-order-functions.sql.out @@ -348,3 +348,837 @@ select aggregate(split('abcdefgh',''), array(array('')), (acc, x) -> array(array struct>> -- !query output [["h"]] + + +-- !query +select aggregate(array(1, 2, 3), 0, 100) as aggregate_int_literal +-- !query schema +struct +-- !query output +100 + + +-- !query +select aggregate(array(1, 2, 3), map(), map('result', 999)) as aggregate_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "third", + "requiredType" : "\"MAP\"", + "sqlExpr" : "\"aggregate(array(1, 2, 3), map(), lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 59, + "fragment" : "aggregate(array(1, 2, 3), map(), map('result', 999))" + } ] +} + + +-- !query +select aggregate(array(1, 2, 3), struct('init', 0), struct('final', 999)) as aggregate_struct_literal +-- !query schema +struct> +-- !query output +{"col1":"final","col2":999} + + +-- !query +select aggregate(array(1, 2, 3), array(), array('result')) as aggregate_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(result), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "third", + "requiredType" : "\"ARRAY\"", + "sqlExpr" : "\"aggregate(array(1, 2, 3), array(), lambdafunction(array(result), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 58, + "fragment" : "aggregate(array(1, 2, 3), array(), array('result'))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), 1) as array_sort_int_literal +-- !query schema +struct> +-- !query output +[3,1,2] + + +-- !query +select array_sort(array(3, 1, 2), map('compare', 0)) as array_sort_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"MAP\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(map(compare, 0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 52, + "fragment" : "array_sort(array(3, 1, 2), map('compare', 0))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), struct('result', 0)) as array_sort_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"STRUCT\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(struct(result, 0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 54, + "fragment" : "array_sort(array(3, 1, 2), struct('result', 0))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), array(0)) as array_sort_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"ARRAY\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(array(0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 43, + "fragment" : "array_sort(array(3, 1, 2), array(0))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), 1) as exists_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "exists(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select exists(array(1, 2, 3), map('found', true)) as exists_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(found, true), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(map(found, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "exists(array(1, 2, 3), map('found', true))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), struct('exists', true)) as exists_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(exists, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(struct(exists, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 53, + "fragment" : "exists(array(1, 2, 3), struct('exists', true))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), array(true)) as exists_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(array(true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 42, + "fragment" : "exists(array(1, 2, 3), array(true))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), 1) as filter_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "filter(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select filter(array(1, 2, 3), map('key', 'value')) as filter_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(key, value), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(map(key, value), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "filter(array(1, 2, 3), map('key', 'value'))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), struct('valid', true)) as filter_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(valid, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(struct(valid, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 52, + "fragment" : "filter(array(1, 2, 3), struct('valid', true))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), array(true, false)) as filter_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true, false), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(array(true, false), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "filter(array(1, 2, 3), array(true, false))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), 1) as forall_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "forall(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select forall(array(1, 2, 3), map('all', true)) as forall_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(all, true), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(map(all, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 47, + "fragment" : "forall(array(1, 2, 3), map('all', true))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), struct('all', true)) as forall_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(all, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(struct(all, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "forall(array(1, 2, 3), struct('all', true))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), array(true, true)) as forall_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true, true), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(array(true, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 48, + "fragment" : "forall(array(1, 2, 3), array(true, true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), 1) as map_filter_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(1, namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 41, + "fragment" : "map_filter(map('a', 1, 'b', 2), 1)" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), map('keep', true)) as map_filter_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(keep, true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(map(keep, true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 57, + "fragment" : "map_filter(map('a', 1, 'b', 2), map('keep', true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), struct('filter', true)) as map_filter_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(filter, true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(struct(filter, true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 62, + "fragment" : "map_filter(map('a', 1, 'b', 2), struct('filter', true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), array(true)) as map_filter_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(array(true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 51, + "fragment" : "map_filter(map('a', 1, 'b', 2), array(true))" + } ] +} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), 100) as map_zipwith_int_literal +-- !query schema +struct> +-- !query output +{"a":100} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), map('merged', true)) as map_zipwith_map_literal +-- !query schema +struct>> +-- !query output +{"a":{"merged":true}} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), struct('left', 1, 'right', 10)) as map_zipwith_struct_literal +-- !query schema +struct>> +-- !query output +{"a":{"col1":"left","col2":1,"col3":"right","col4":10}} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), array('combined')) as map_zipwith_array_literal +-- !query schema +struct>> +-- !query output +{"a":["combined"]} + + +-- !query +select reduce(array(1, 2, 3), 0, 100) as reduce_int_literal +-- !query schema +struct +-- !query output +100 + + +-- !query +select reduce(array(1, 2, 3), map(), map('result', 999)) as reduce_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "third", + "requiredType" : "\"MAP\"", + "sqlExpr" : "\"reduce(array(1, 2, 3), map(), lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 56, + "fragment" : "reduce(array(1, 2, 3), map(), map('result', 999))" + } ] +} + + +-- !query +select reduce(array(1, 2, 3), struct('init', 0), struct('final', 999)) as reduce_struct_literal +-- !query schema +struct> +-- !query output +{"col1":"final","col2":999} + + +-- !query +select reduce(array(1, 2, 3), array(), array('result')) as reduce_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(result), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "third", + "requiredType" : "\"ARRAY\"", + "sqlExpr" : "\"reduce(array(1, 2, 3), array(), lambdafunction(array(result), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 55, + "fragment" : "reduce(array(1, 2, 3), array(), array('result'))" + } ] +} + + +-- !query +select transform(array(1, 2, 3), 42) as transform_int_literal +-- !query schema +struct> +-- !query output +[42,42,42] + + +-- !query +select transform(array(1, 2, 3), map('key', 'value')) as transform_map_literal +-- !query schema +struct>> +-- !query output +[{"key":"value"},{"key":"value"},{"key":"value"}] + + +-- !query +select transform(array(1, 2, 3), struct('id', 99, 'name', 'test')) as transform_struct_literal +-- !query schema +struct>> +-- !query output +[{"col1":"id","col2":99,"col3":"name","col4":"test"},{"col1":"id","col2":99,"col3":"name","col4":"test"},{"col1":"id","col2":99,"col3":"name","col4":"test"}] + + +-- !query +select transform(array(1, 2, 3), array('a', 'b')) as transform_array_literal +-- !query schema +struct>> +-- !query output +[["a","b"],["a","b"],["a","b"]] + + +-- !query +select transform_keys(map('a', 1, 'b', 2), 42) as transform_keys_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.SparkRuntimeException +{ + "errorClass" : "DUPLICATED_MAP_KEY", + "sqlState" : "23505", + "messageParameters" : { + "key" : "42", + "mapKeyDedupPolicy" : "\"spark.sql.mapKeyDedupPolicy\"" + } +} + + +-- !query +select transform_keys(map('a', 1, 'b', 2), map('new', 'key')) as transform_keys_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.INVALID_MAP_KEY_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "keyType" : "\"MAP\"", + "sqlExpr" : "\"transform_keys(map(a, 1, b, 2), lambdafunction(map(new, key), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 61, + "fragment" : "transform_keys(map('a', 1, 'b', 2), map('new', 'key'))" + } ] +} + + +-- !query +select transform_keys(map('a', 1, 'b', 2), struct('key', 'value')) as transform_keys_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.SparkRuntimeException +{ + "errorClass" : "DUPLICATED_MAP_KEY", + "sqlState" : "23505", + "messageParameters" : { + "key" : "[key,value]", + "mapKeyDedupPolicy" : "\"spark.sql.mapKeyDedupPolicy\"" + } +} + + +-- !query +select transform_keys(map('a', 1, 'b', 2), array('new_key')) as transform_keys_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.SparkRuntimeException +{ + "errorClass" : "DUPLICATED_MAP_KEY", + "sqlState" : "23505", + "messageParameters" : { + "key" : "[new_key]", + "mapKeyDedupPolicy" : "\"spark.sql.mapKeyDedupPolicy\"" + } +} + + +-- !query +select transform_values(map('a', 1, 'b', 2), 999) as transform_values_int_literal +-- !query schema +struct> +-- !query output +{"a":999,"b":999} + + +-- !query +select transform_values(map('a', 1, 'b', 2), map('new', 'value')) as transform_values_map_literal +-- !query schema +struct>> +-- !query output +{"a":{"new":"value"},"b":{"new":"value"}} + + +-- !query +select transform_values(map('a', 1, 'b', 2), struct('val', 999)) as transform_values_struct_literal +-- !query schema +struct>> +-- !query output +{"a":{"col1":"val","col2":999},"b":{"col1":"val","col2":999}} + + +-- !query +select transform_values(map('a', 1, 'b', 2), array('new_value')) as transform_values_array_literal +-- !query schema +struct>> +-- !query output +{"a":["new_value"],"b":["new_value"]} + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), 100) as zipwith_int_literal +-- !query schema +struct> +-- !query output +[100,100,100] + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), map('merged', true)) as zipwith_map_literal +-- !query schema +struct>> +-- !query output +[{"merged":true},{"merged":true},{"merged":true}] + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), struct('left', 1, 'right', 2)) as zipwith_struct_literal +-- !query schema +struct>> +-- !query output +[{"col1":"left","col2":1,"col3":"right","col4":2},{"col1":"left","col2":1,"col3":"right","col4":2},{"col1":"left","col2":1,"col3":"right","col4":2}] + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), array('combined')) as zipwith_array_literal +-- !query schema +struct>> +-- !query output +[["combined"],["combined"],["combined"]] diff --git a/sql/core/src/test/resources/sql-tests/results/nonansi/higher-order-functions.sql.out b/sql/core/src/test/resources/sql-tests/results/nonansi/higher-order-functions.sql.out index 7bfc35a61e092..b16bbcda2eb5a 100644 --- a/sql/core/src/test/resources/sql-tests/results/nonansi/higher-order-functions.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/nonansi/higher-order-functions.sql.out @@ -348,3 +348,837 @@ select aggregate(split('abcdefgh',''), array(array('')), (acc, x) -> array(array struct>> -- !query output [["h"]] + + +-- !query +select aggregate(array(1, 2, 3), 0, 100) as aggregate_int_literal +-- !query schema +struct +-- !query output +100 + + +-- !query +select aggregate(array(1, 2, 3), map(), map('result', 999)) as aggregate_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "third", + "requiredType" : "\"MAP\"", + "sqlExpr" : "\"aggregate(array(1, 2, 3), map(), lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 59, + "fragment" : "aggregate(array(1, 2, 3), map(), map('result', 999))" + } ] +} + + +-- !query +select aggregate(array(1, 2, 3), struct('init', 0), struct('final', 999)) as aggregate_struct_literal +-- !query schema +struct> +-- !query output +{"col1":"final","col2":999} + + +-- !query +select aggregate(array(1, 2, 3), array(), array('result')) as aggregate_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(result), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "third", + "requiredType" : "\"ARRAY\"", + "sqlExpr" : "\"aggregate(array(1, 2, 3), array(), lambdafunction(array(result), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 58, + "fragment" : "aggregate(array(1, 2, 3), array(), array('result'))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), 1) as array_sort_int_literal +-- !query schema +struct> +-- !query output +[3,1,2] + + +-- !query +select array_sort(array(3, 1, 2), map('compare', 0)) as array_sort_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"MAP\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(map(compare, 0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 52, + "fragment" : "array_sort(array(3, 1, 2), map('compare', 0))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), struct('result', 0)) as array_sort_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"STRUCT\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(struct(result, 0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 54, + "fragment" : "array_sort(array(3, 1, 2), struct('result', 0))" + } ] +} + + +-- !query +select array_sort(array(3, 1, 2), array(0)) as array_sort_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_RETURN_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "actualType" : "\"ARRAY\"", + "expectedType" : "\"INT\"", + "functionName" : "`lambdafunction`", + "sqlExpr" : "\"array_sort(array(3, 1, 2), lambdafunction(array(0), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 43, + "fragment" : "array_sort(array(3, 1, 2), array(0))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), 1) as exists_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "exists(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select exists(array(1, 2, 3), map('found', true)) as exists_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(found, true), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(map(found, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "exists(array(1, 2, 3), map('found', true))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), struct('exists', true)) as exists_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(exists, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(struct(exists, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 53, + "fragment" : "exists(array(1, 2, 3), struct('exists', true))" + } ] +} + + +-- !query +select exists(array(1, 2, 3), array(true)) as exists_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"exists(array(1, 2, 3), lambdafunction(array(true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 42, + "fragment" : "exists(array(1, 2, 3), array(true))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), 1) as filter_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "filter(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select filter(array(1, 2, 3), map('key', 'value')) as filter_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(key, value), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(map(key, value), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "filter(array(1, 2, 3), map('key', 'value'))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), struct('valid', true)) as filter_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(valid, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(struct(valid, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 52, + "fragment" : "filter(array(1, 2, 3), struct('valid', true))" + } ] +} + + +-- !query +select filter(array(1, 2, 3), array(true, false)) as filter_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true, false), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"filter(array(1, 2, 3), lambdafunction(array(true, false), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "filter(array(1, 2, 3), array(true, false))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), 1) as forall_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 32, + "fragment" : "forall(array(1, 2, 3), 1)" + } ] +} + + +-- !query +select forall(array(1, 2, 3), map('all', true)) as forall_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(all, true), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(map(all, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 47, + "fragment" : "forall(array(1, 2, 3), map('all', true))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), struct('all', true)) as forall_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(all, true), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(struct(all, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "forall(array(1, 2, 3), struct('all', true))" + } ] +} + + +-- !query +select forall(array(1, 2, 3), array(true, true)) as forall_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true, true), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"forall(array(1, 2, 3), lambdafunction(array(true, true), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 48, + "fragment" : "forall(array(1, 2, 3), array(true, true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), 1) as map_filter_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(1, namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"INT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(1, namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 41, + "fragment" : "map_filter(map('a', 1, 'b', 2), 1)" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), map('keep', true)) as map_filter_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(keep, true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(map(keep, true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 57, + "fragment" : "map_filter(map('a', 1, 'b', 2), map('keep', true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), struct('filter', true)) as map_filter_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(struct(filter, true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"STRUCT\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(struct(filter, true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 62, + "fragment" : "map_filter(map('a', 1, 'b', 2), struct('filter', true))" + } ] +} + + +-- !query +select map_filter(map('a', 1, 'b', 2), array(true)) as map_filter_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(true), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "second", + "requiredType" : "\"BOOLEAN\"", + "sqlExpr" : "\"map_filter(map(a, 1, b, 2), lambdafunction(array(true), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 51, + "fragment" : "map_filter(map('a', 1, 'b', 2), array(true))" + } ] +} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), 100) as map_zipwith_int_literal +-- !query schema +struct> +-- !query output +{"a":100} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), map('merged', true)) as map_zipwith_map_literal +-- !query schema +struct>> +-- !query output +{"a":{"merged":true}} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), struct('left', 1, 'right', 10)) as map_zipwith_struct_literal +-- !query schema +struct>> +-- !query output +{"a":{"col1":"left","col2":1,"col3":"right","col4":10}} + + +-- !query +select map_zip_with(map('a', 1), map('a', 10), array('combined')) as map_zipwith_array_literal +-- !query schema +struct>> +-- !query output +{"a":["combined"]} + + +-- !query +select reduce(array(1, 2, 3), 0, 100) as reduce_int_literal +-- !query schema +struct +-- !query output +100 + + +-- !query +select reduce(array(1, 2, 3), map(), map('result', 999)) as reduce_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"MAP\"", + "paramIndex" : "third", + "requiredType" : "\"MAP\"", + "sqlExpr" : "\"reduce(array(1, 2, 3), map(), lambdafunction(map(result, 999), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 56, + "fragment" : "reduce(array(1, 2, 3), map(), map('result', 999))" + } ] +} + + +-- !query +select reduce(array(1, 2, 3), struct('init', 0), struct('final', 999)) as reduce_struct_literal +-- !query schema +struct> +-- !query output +{"col1":"final","col2":999} + + +-- !query +select reduce(array(1, 2, 3), array(), array('result')) as reduce_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"lambdafunction(array(result), namedlambdavariable(), namedlambdavariable())\"", + "inputType" : "\"ARRAY\"", + "paramIndex" : "third", + "requiredType" : "\"ARRAY\"", + "sqlExpr" : "\"reduce(array(1, 2, 3), array(), lambdafunction(array(result), namedlambdavariable(), namedlambdavariable()), lambdafunction(namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 55, + "fragment" : "reduce(array(1, 2, 3), array(), array('result'))" + } ] +} + + +-- !query +select transform(array(1, 2, 3), 42) as transform_int_literal +-- !query schema +struct> +-- !query output +[42,42,42] + + +-- !query +select transform(array(1, 2, 3), map('key', 'value')) as transform_map_literal +-- !query schema +struct>> +-- !query output +[{"key":"value"},{"key":"value"},{"key":"value"}] + + +-- !query +select transform(array(1, 2, 3), struct('id', 99, 'name', 'test')) as transform_struct_literal +-- !query schema +struct>> +-- !query output +[{"col1":"id","col2":99,"col3":"name","col4":"test"},{"col1":"id","col2":99,"col3":"name","col4":"test"},{"col1":"id","col2":99,"col3":"name","col4":"test"}] + + +-- !query +select transform(array(1, 2, 3), array('a', 'b')) as transform_array_literal +-- !query schema +struct>> +-- !query output +[["a","b"],["a","b"],["a","b"]] + + +-- !query +select transform_keys(map('a', 1, 'b', 2), 42) as transform_keys_int_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.SparkRuntimeException +{ + "errorClass" : "DUPLICATED_MAP_KEY", + "sqlState" : "23505", + "messageParameters" : { + "key" : "42", + "mapKeyDedupPolicy" : "\"spark.sql.mapKeyDedupPolicy\"" + } +} + + +-- !query +select transform_keys(map('a', 1, 'b', 2), map('new', 'key')) as transform_keys_map_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.INVALID_MAP_KEY_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "keyType" : "\"MAP\"", + "sqlExpr" : "\"transform_keys(map(a, 1, b, 2), lambdafunction(map(new, key), namedlambdavariable(), namedlambdavariable()))\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 61, + "fragment" : "transform_keys(map('a', 1, 'b', 2), map('new', 'key'))" + } ] +} + + +-- !query +select transform_keys(map('a', 1, 'b', 2), struct('key', 'value')) as transform_keys_struct_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.SparkRuntimeException +{ + "errorClass" : "DUPLICATED_MAP_KEY", + "sqlState" : "23505", + "messageParameters" : { + "key" : "[key,value]", + "mapKeyDedupPolicy" : "\"spark.sql.mapKeyDedupPolicy\"" + } +} + + +-- !query +select transform_keys(map('a', 1, 'b', 2), array('new_key')) as transform_keys_array_literal +-- !query schema +struct<> +-- !query output +org.apache.spark.SparkRuntimeException +{ + "errorClass" : "DUPLICATED_MAP_KEY", + "sqlState" : "23505", + "messageParameters" : { + "key" : "[new_key]", + "mapKeyDedupPolicy" : "\"spark.sql.mapKeyDedupPolicy\"" + } +} + + +-- !query +select transform_values(map('a', 1, 'b', 2), 999) as transform_values_int_literal +-- !query schema +struct> +-- !query output +{"a":999,"b":999} + + +-- !query +select transform_values(map('a', 1, 'b', 2), map('new', 'value')) as transform_values_map_literal +-- !query schema +struct>> +-- !query output +{"a":{"new":"value"},"b":{"new":"value"}} + + +-- !query +select transform_values(map('a', 1, 'b', 2), struct('val', 999)) as transform_values_struct_literal +-- !query schema +struct>> +-- !query output +{"a":{"col1":"val","col2":999},"b":{"col1":"val","col2":999}} + + +-- !query +select transform_values(map('a', 1, 'b', 2), array('new_value')) as transform_values_array_literal +-- !query schema +struct>> +-- !query output +{"a":["new_value"],"b":["new_value"]} + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), 100) as zipwith_int_literal +-- !query schema +struct> +-- !query output +[100,100,100] + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), map('merged', true)) as zipwith_map_literal +-- !query schema +struct>> +-- !query output +[{"merged":true},{"merged":true},{"merged":true}] + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), struct('left', 1, 'right', 2)) as zipwith_struct_literal +-- !query schema +struct>> +-- !query output +[{"col1":"left","col2":1,"col3":"right","col4":2},{"col1":"left","col2":1,"col3":"right","col4":2},{"col1":"left","col2":1,"col3":"right","col4":2}] + + +-- !query +select zip_with(array(1, 2, 3), array(4, 5, 6), array('combined')) as zipwith_array_literal +-- !query schema +struct>> +-- !query output +[["combined"],["combined"],["combined"]]