diff --git a/.gitignore b/.gitignore index 18503bf3..71f35b17 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,6 @@ Gemfile.lock tmp/* pkg/* coverage/ +/modelgen/java-extractor/.gradle/ +/modelgen/java-extractor/build/ +/modelgen/java-extractor/.idea/ diff --git a/modelgen/compare_model_shapes.rb b/modelgen/compare_model_shapes.rb new file mode 100644 index 00000000..e695861c --- /dev/null +++ b/modelgen/compare_model_shapes.rb @@ -0,0 +1,128 @@ +# frozen_string_literal: true + +require "json" + +if ARGV.length != 3 + warn <<~USAGE + Usage: + ruby modelgen/compare_model_shapes.rb \ + \ + \ + + USAGE + + exit 1 +end + +version, old_path, new_path = ARGV + +module Trino + module Client + module ModelVersions + end + end +end + +module_name = :"V#{version.tr('.', '_')}" + +def capture_shape( + module_name:, + path: +) + model_versions = + Trino::Client::ModelVersions + + if model_versions.const_defined?( + module_name, + false, + ) + model_versions.send( + :remove_const, + module_name, + ) + end + + load File.expand_path(path) + + version_module = model_versions.const_get( + module_name, + false, + ) + + shape = {} + + version_module + .constants(false) + .sort + .each do |constant_name| + value = version_module.const_get( + constant_name, + false, + ) + + next unless value.respond_to?(:members) + + shape[constant_name.to_s] = + value.members.map(&:to_s) + end + + model_versions.send( + :remove_const, + module_name, + ) + + shape +end + +old_shape = capture_shape( + module_name: module_name, + path: old_path, + ) + +new_shape = capture_shape( + module_name: module_name, + path: new_path, + ) + +missing_models = + old_shape.keys - new_shape.keys + +added_models = + new_shape.keys - old_shape.keys + +missing_fields = {} +added_fields = {} + +(old_shape.keys & new_shape.keys).each do |model| + old_fields = old_shape.fetch(model) + new_fields = new_shape.fetch(model) + + missing = old_fields - new_fields + added = new_fields - old_fields + + missing_fields[model] = missing \ + unless missing.empty? + + added_fields[model] = added \ + unless added.empty? +end + +result = { + missingModels: missing_models.sort, + addedModels: added_models.sort, + missingFields: missing_fields, + addedFields: added_fields, +} + +puts JSON.pretty_generate(result) + +has_regression = + !missing_models.empty? || + !missing_fields.empty? + +if has_regression + warn "Compatibility check failed." + exit 1 +end + +puts "Compatibility check passed." \ No newline at end of file diff --git a/modelgen/generate_from_schema.rb b/modelgen/generate_from_schema.rb new file mode 100644 index 00000000..6e13a1df --- /dev/null +++ b/modelgen/generate_from_schema.rb @@ -0,0 +1,62 @@ +# frozen_string_literal: true + +require "erb" +require "fileutils" +require "json" + +require_relative "schema_formatter" + +if ARGV.length != 3 + warn <<~USAGE + Usage: + ruby modelgen/generate_from_schema.rb \ + \ + \ + + USAGE + + exit 1 +end + +model_version, schema_path, output_path = ARGV + +schema = JSON.parse( + File.read(schema_path), + ) + +schema_version = schema.fetch( + "trinoVersion", + ) + +unless schema_version == model_version + raise ArgumentError, + "Version mismatch: argument=#{model_version.inspect}, " \ + "schema=#{schema_version.inspect}" +end + +formatter = TrinoModels::SchemaFormatter.new( + schema, + ) + +@contents = formatter.format +@model_version = model_version + +template_path = File.expand_path( + "model_versions.rb", + __dir__, + ) + +template = ERB.new( + File.read(template_path), + ) + +FileUtils.mkdir_p( + File.dirname(output_path), + ) + +File.write( + output_path, + template.result(binding), + ) + +puts "Generated #{output_path}." \ No newline at end of file diff --git a/modelgen/java-extractor/build.gradle b/modelgen/java-extractor/build.gradle new file mode 100644 index 00000000..1c0c3810 --- /dev/null +++ b/modelgen/java-extractor/build.gradle @@ -0,0 +1,83 @@ +plugins { + id 'application' + id 'java' +} + +repositories { + mavenCentral() +} + +def trinoVersion = providers + .gradleProperty('trinoVersion') + .getOrElse('483') + +def javaVersion = providers + .gradleProperty('javaVersion') + .getOrElse('25') + .toInteger() + +java { + toolchain { + languageVersion = JavaLanguageVersion.of(javaVersion) + } +} + +dependencies { + implementation "io.trino:trino-client:${trinoVersion}" + implementation "io.trino:trino-main:${trinoVersion}" + + implementation "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}" + implementation "com.fasterxml.jackson.datatype:jackson-datatype-jdk8:${jacksonVersion}" + implementation "com.fasterxml.jackson.module:jackson-module-parameter-names:${jacksonVersion}" + + testImplementation platform('org.junit:junit-bom:5.11.4') + testImplementation 'org.junit.jupiter:junit-jupiter' + testRuntimeOnly 'org.junit.platform:junit-platform-launcher' +} + +application { + mainClass = 'org.trinoruby.modelgen.ModelExtractor' +} + +test { + useJUnitPlatform() +} + +tasks.register('extractModels', JavaExec) { + group = 'model generation' + description = 'Extracts Trino models into an intermediate JSON schema' + + classpath = sourceSets.main.runtimeClasspath + mainClass = application.mainClass + + def version = trinoVersion + + def rootsFile = layout.projectDirectory.file( + "config/roots-${version}.txt" + ) + + def outputFile = layout.projectDirectory.file( + "../schemas/${version}.json" + ) + + args( + '--trino-version', version, + '--roots', rootsFile.asFile.absolutePath, + '--output', outputFile.asFile.absolutePath + ) + + doFirst { + println "Extractor Java: ${javaLauncher.get().executablePath}" + println "Trino version: ${version}" + println "Roots: ${rootsFile.asFile}" + println "Output: ${outputFile.asFile}" + } +} + +tasks.register('printRuntimeClasspath') { + group = 'help' + + doLast { + println sourceSets.main.runtimeClasspath.asPath + } +} \ No newline at end of file diff --git a/modelgen/java-extractor/config/roots-351.txt b/modelgen/java-extractor/config/roots-351.txt new file mode 100644 index 00000000..53012255 --- /dev/null +++ b/modelgen/java-extractor/config/roots-351.txt @@ -0,0 +1,59 @@ +# Trino REST API root model +# Fully qualified class name + +io.trino.client.QueryResults +io.trino.execution.QueryInfo +io.trino.server.BasicQueryInfo + +io.trino.sql.planner.plan.OutputNode +io.trino.sql.planner.plan.ProjectNode +io.trino.sql.planner.plan.TableScanNode +io.trino.sql.planner.plan.ValuesNode +io.trino.sql.planner.plan.AggregationNode +io.trino.sql.planner.plan.MarkDistinctNode +io.trino.sql.planner.plan.FilterNode +io.trino.sql.planner.plan.WindowNode +io.trino.sql.planner.plan.RowNumberNode +io.trino.sql.planner.plan.TopNRowNumberNode +io.trino.sql.planner.plan.LimitNode +io.trino.sql.planner.plan.DistinctLimitNode +io.trino.sql.planner.plan.TopNNode +io.trino.sql.planner.plan.SampleNode +io.trino.sql.planner.plan.SortNode +io.trino.sql.planner.plan.RemoteSourceNode +io.trino.sql.planner.plan.JoinNode +io.trino.sql.planner.plan.SemiJoinNode +io.trino.sql.planner.plan.SpatialJoinNode +io.trino.sql.planner.plan.IndexJoinNode +io.trino.sql.planner.plan.IndexSourceNode +io.trino.sql.planner.plan.TableWriterNode +io.trino.sql.planner.plan.DeleteNode +io.trino.sql.planner.plan.TableFinishNode +io.trino.sql.planner.plan.UnnestNode +io.trino.sql.planner.plan.ExchangeNode +io.trino.sql.planner.plan.UnionNode +io.trino.sql.planner.plan.IntersectNode +io.trino.sql.planner.plan.EnforceSingleRowNode +io.trino.sql.planner.plan.GroupIdNode +io.trino.sql.planner.plan.ExplainAnalyzeNode +io.trino.sql.planner.plan.ApplyNode +io.trino.sql.planner.plan.AssignUniqueId +io.trino.sql.planner.plan.CorrelatedJoinNode +io.trino.sql.planner.plan.StatisticsWriterNode +io.trino.metadata.AnalyzeTableHandle +io.trino.metadata.InsertTableHandle +io.trino.metadata.OutputTableHandle +io.trino.operator.ExchangeClientStatus +io.trino.operator.JoinOperatorInfo +io.trino.operator.PageBufferClientStatus +io.trino.operator.PartitionedOutputOperator$PartitionedOutputInfo +io.trino.operator.SplitOperatorInfo +io.trino.operator.TableFinishInfo +io.trino.operator.TableWriterOperator$TableWriterInfo +io.trino.operator.WindowInfo +io.trino.operator.WindowInfo$DriverWindowInfo +io.trino.operator.exchange.LocalExchangeBufferInfo +io.trino.sql.planner.plan.StatisticsWriterNode$WriteStatisticsHandle +io.trino.sql.planner.plan.TableWriterNode$CreateTarget +io.trino.sql.planner.plan.TableWriterNode$InsertTarget +io.trino.sql.planner.plan.TableWriterNode$RefreshMaterializedViewTarget diff --git a/modelgen/java-extractor/config/roots-483.txt b/modelgen/java-extractor/config/roots-483.txt new file mode 100644 index 00000000..6df51150 --- /dev/null +++ b/modelgen/java-extractor/config/roots-483.txt @@ -0,0 +1,53 @@ +# Trino REST API root model +# Fully qualified class name + +io.trino.client.QueryResults +io.trino.execution.QueryInfo +io.trino.server.BasicQueryInfo + +io.trino.sql.planner.plan.OutputNode +io.trino.sql.planner.plan.ProjectNode +io.trino.sql.planner.plan.TableScanNode +io.trino.sql.planner.plan.ValuesNode +io.trino.sql.planner.plan.AggregationNode +io.trino.sql.planner.plan.MarkDistinctNode +io.trino.sql.planner.plan.FilterNode +io.trino.sql.planner.plan.WindowNode +io.trino.sql.planner.plan.RowNumberNode +io.trino.sql.planner.plan.LimitNode +io.trino.sql.planner.plan.DistinctLimitNode +io.trino.sql.planner.plan.TopNNode +io.trino.sql.planner.plan.SampleNode +io.trino.sql.planner.plan.SortNode +io.trino.sql.planner.plan.RemoteSourceNode +io.trino.sql.planner.plan.JoinNode +io.trino.sql.planner.plan.SemiJoinNode +io.trino.sql.planner.plan.SpatialJoinNode +io.trino.sql.planner.plan.IndexJoinNode +io.trino.sql.planner.plan.IndexSourceNode +io.trino.sql.planner.plan.TableWriterNode +io.trino.sql.planner.plan.TableFinishNode +io.trino.sql.planner.plan.UnnestNode +io.trino.sql.planner.plan.ExchangeNode +io.trino.sql.planner.plan.UnionNode +io.trino.sql.planner.plan.IntersectNode +io.trino.sql.planner.plan.EnforceSingleRowNode +io.trino.sql.planner.plan.GroupIdNode +io.trino.sql.planner.plan.ExplainAnalyzeNode +io.trino.sql.planner.plan.ApplyNode +io.trino.sql.planner.plan.AssignUniqueId +io.trino.sql.planner.plan.CorrelatedJoinNode +io.trino.sql.planner.plan.StatisticsWriterNode +io.trino.metadata.AnalyzeTableHandle +io.trino.metadata.InsertTableHandle +io.trino.metadata.OutputTableHandle +io.trino.operator.PageBufferClientStatus +io.trino.operator.TableFinishInfo +io.trino.operator.TableWriterOperator$TableWriterInfo +io.trino.operator.WindowInfo +io.trino.operator.WindowInfo$DriverWindowInfo +io.trino.operator.exchange.LocalExchangeBufferInfo +io.trino.sql.planner.plan.StatisticsWriterNode$WriteStatisticsHandle +io.trino.sql.planner.plan.TableWriterNode$CreateTarget +io.trino.sql.planner.plan.TableWriterNode$InsertTarget +io.trino.sql.planner.plan.TableWriterNode$RefreshMaterializedViewTarget diff --git a/modelgen/java-extractor/gradle.properties b/modelgen/java-extractor/gradle.properties new file mode 100644 index 00000000..84a2de60 --- /dev/null +++ b/modelgen/java-extractor/gradle.properties @@ -0,0 +1,7 @@ +trinoVersion=483 +# The JDK version capable of loading Trino class files +javaVersion=25 +jacksonVersion=2.22.3 + +org.gradle.jvmargs=-Xmx2g +org.gradle.caching=true \ No newline at end of file diff --git a/modelgen/java-extractor/gradle/wrapper/gradle-wrapper.jar b/modelgen/java-extractor/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 00000000..b1b8ef56 Binary files /dev/null and b/modelgen/java-extractor/gradle/wrapper/gradle-wrapper.jar differ diff --git a/modelgen/java-extractor/gradle/wrapper/gradle-wrapper.properties b/modelgen/java-extractor/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000..eb84db68 --- /dev/null +++ b/modelgen/java-extractor/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,9 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-9.6.0-bin.zip +networkTimeout=10000 +retries=0 +retryBackOffMs=500 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/modelgen/java-extractor/gradlew b/modelgen/java-extractor/gradlew new file mode 100755 index 00000000..249efbb0 --- /dev/null +++ b/modelgen/java-extractor/gradlew @@ -0,0 +1,248 @@ +#!/bin/sh + +# +# Copyright © 2015 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# gradlew start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh gradlew +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/modelgen/java-extractor/gradlew.bat b/modelgen/java-extractor/gradlew.bat new file mode 100644 index 00000000..8508ef68 --- /dev/null +++ b/modelgen/java-extractor/gradlew.bat @@ -0,0 +1,82 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem gradlew startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables, and ensure extensions are enabled +setlocal EnableExtensions + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +"%COMSPEC%" /c exit 1 + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +"%COMSPEC%" /c exit 1 + +:execute +@rem Setup the command line + + + +@rem Execute gradlew +@rem endlocal doesn't take effect until after the line is parsed and variables are expanded +@rem which allows us to clear the local environment before executing the java command +endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel + +:exitWithErrorLevel +@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts +"%COMSPEC%" /c exit %ERRORLEVEL% diff --git a/modelgen/java-extractor/settings.gradle b/modelgen/java-extractor/settings.gradle new file mode 100644 index 00000000..9a23c7c0 --- /dev/null +++ b/modelgen/java-extractor/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'trino-model-extractor' \ No newline at end of file diff --git a/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/ModelExtractor.java b/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/ModelExtractor.java new file mode 100644 index 00000000..aafeaff8 --- /dev/null +++ b/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/ModelExtractor.java @@ -0,0 +1,455 @@ +package org.trinoruby.modelgen; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.databind.BeanDescription; +import com.fasterxml.jackson.databind.JavaType; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.introspect.AnnotatedMember; +import com.fasterxml.jackson.databind.introspect.AnnotatedParameter; +import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition; +import com.fasterxml.jackson.datatype.jdk8.Jdk8Module; +import com.fasterxml.jackson.module.paramnames.ParameterNamesModule; + +import java.io.IOException; +import java.lang.annotation.Annotation; +import java.lang.reflect.Modifier; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Queue; +import java.util.Set; + +import static org.trinoruby.modelgen.ModelSchema.ModelDefinition; +import static org.trinoruby.modelgen.ModelSchema.PropertyDefinition; + +public final class ModelExtractor +{ + private final ObjectMapper objectMapper; + private final TypeClassifier typeClassifier; + + private ModelExtractor( + ObjectMapper objectMapper, + TypeClassifier typeClassifier) + { + this.objectMapper = objectMapper; + this.typeClassifier = typeClassifier; + } + + static void main(String[] args) + throws Exception + { + Arguments arguments = + Arguments.parse(args); + + List roots = + readConfigLines(arguments.roots()); + + ObjectMapper objectMapper = + createObjectMapper(); + + ModelExtractor extractor = + new ModelExtractor( + objectMapper, + new TypeClassifier( + objectMapper.getTypeFactory())); + + ModelSchema schema = + extractor.extract( + arguments.trinoVersion(), + roots); + + Path output = arguments.output(); + + if (output.getParent() != null) { + Files.createDirectories( + output.getParent()); + } + + objectMapper + .writerWithDefaultPrettyPrinter() + .writeValue( + output.toFile(), + schema); + + System.out.printf( + "Generated %s with %d models.%n", + output, + schema.models().size()); + } + + static ObjectMapper createObjectMapper() + { + return new ObjectMapper() + .registerModule(new Jdk8Module()) + .registerModule( + new ParameterNamesModule()) + .setSerializationInclusion( + JsonInclude.Include.NON_NULL); + } + + private ModelSchema extract( + String trinoVersion, + List rootClassNames) + throws ClassNotFoundException + { + Queue> pending = + new ArrayDeque<>(); + + Set enqueued = + new HashSet<>(); + + for (String rootClassName : + rootClassNames) { + Class rootClass = + Class.forName( + rootClassName, + false, + Thread.currentThread() + .getContextClassLoader()); + + pending.add(rootClass); + enqueued.add(rootClass.getName()); + } + + Map models = + new LinkedHashMap<>(); + + while (!pending.isEmpty()) { + Class modelClass = + pending.remove(); + + if (models.containsKey( + modelClass.getName())) { + continue; + } + + System.err.println( + "Extracting model: " + + modelClass.getName()); + + ExtractedModel extracted = + extractModel(modelClass); + + models.put( + modelClass.getName(), + extracted.definition()); + + List> referencedModels = + extracted.referencedModels().stream() + .sorted( + Comparator.comparing( + Class::getName)) + .toList(); + + for (Class referencedModel : + referencedModels) { + if (enqueued.add( + referencedModel.getName())) { + pending.add(referencedModel); + } + } + } + + List sortedModels = + models.values().stream() + .sorted( + Comparator.comparing( + ModelDefinition::javaName)) + .toList(); + + return new ModelSchema( + 1, + trinoVersion, + List.copyOf(rootClassNames), + sortedModels); + } + + private ExtractedModel extractModel( + Class modelClass) + { + JavaType javaType = + objectMapper + .getTypeFactory() + .constructType(modelClass); + + BeanDescription description = + objectMapper + .getDeserializationConfig() + .introspect(javaType); + + List indexedProperties = + new ArrayList<>(); + + Set> referencedModels = + new HashSet<>(); + + int discoveryIndex = 0; + + for (BeanPropertyDefinition property : + description.findProperties()) { + AnnotatedParameter constructorParameter = + property.getConstructorParameter(); + + /* + * 既存modelgenとの互換性を優先し、 + * @JsonCreator constructor parameterのみを対象にする。 + */ + if (constructorParameter == null) { + continue; + } + + JavaType propertyType = + constructorParameter.getType(); + + TypeClassifier.Classification classification; + + try { + classification = + typeClassifier.classify( + propertyType); + } + catch (RuntimeException exception) { + throw new IllegalArgumentException( + "Failed to classify property: " + + modelClass.getName() + + "#" + + property.getName() + + " [javaName=" + + property.getInternalName() + + ", type=" + + propertyType.toCanonical() + + ", creatorParameter=true]", + exception); + } + + referencedModels.addAll( + classification.referencedModels()); + + int creatorIndex = + constructorParameter.getIndex(); + + String javaName = + property.getInternalName() == null + ? property.getName() + : property.getInternalName(); + + String nullability = + determineNullability( + property, + constructorParameter, + propertyType); + + PropertyDefinition definition = + new PropertyDefinition( + property.getName(), + javaName, + creatorIndex, + nullability, + classification.type()); + + indexedProperties.add( + new IndexedProperty( + definition, + creatorIndex, + discoveryIndex)); + + discoveryIndex++; + } + + if (indexedProperties.isEmpty()) { + String modelKind; + + if (modelClass.isInterface()) { + modelKind = "interface"; + } + else if (Modifier.isAbstract( + modelClass.getModifiers())) { + modelKind = "abstract class"; + } + else if (modelClass.isRecord()) { + modelKind = "record"; + } + else { + modelKind = "class"; + } + + throw new IllegalStateException( + "Jackson found no deserializable " + + "constructor properties for " + + modelClass.getName() + + " (" + + modelKind + + ")."); + } + + indexedProperties.sort( + Comparator.comparingInt( + IndexedProperty::creatorIndex) + .thenComparingInt( + IndexedProperty::discoveryIndex)); + + List properties = + indexedProperties.stream() + .map(IndexedProperty::definition) + .toList(); + + String kind = + modelClass.isRecord() + ? "record" + : "class"; + + ModelDefinition definition = + new ModelDefinition( + modelClass.getName(), + modelClass.getSimpleName(), + kind, + properties); + + referencedModels.remove(modelClass); + + return new ExtractedModel( + definition, + Set.copyOf(referencedModels)); + } + + private static String determineNullability( + BeanPropertyDefinition property, + AnnotatedParameter constructorParameter, + JavaType propertyType) + { + Class rawClass = + propertyType.getRawClass(); + + if (rawClass.isPrimitive()) { + return "non_null"; + } + + if (rawClass == java.util.Optional.class + || rawClass == java.util.OptionalInt.class + || rawClass == java.util.OptionalLong.class + || rawClass == java.util.OptionalDouble.class) { + return "nullable"; + } + + if (hasNullableAnnotation( + constructorParameter)) { + return "nullable"; + } + + if (property.isRequired()) { + return "non_null"; + } + + return "unknown"; + } + + private static boolean hasNullableAnnotation( + AnnotatedMember member) + { + if (member == null) { + return false; + } + + for (Annotation annotation : + member.annotations()) { + String simpleName = + annotation + .annotationType() + .getSimpleName(); + + if (simpleName.equals("Nullable")) { + return true; + } + } + + return false; + } + + private static List readConfigLines( + Path path) + throws IOException + { + return Files.readAllLines(path).stream() + .map(String::trim) + .filter(line -> !line.isEmpty()) + .filter(line -> + !line.startsWith("#")) + .toList(); + } + + private record ExtractedModel( + ModelDefinition definition, + Set> referencedModels) + { + } + + private record IndexedProperty( + PropertyDefinition definition, + int creatorIndex, + int discoveryIndex) + { + } + + private record Arguments( + String trinoVersion, + Path roots, + Path output) + { + static Arguments parse(String[] args) + { + if (args.length % 2 != 0) { + throw new IllegalArgumentException( + "Arguments must be provided " + + "as name/value pairs."); + } + + Map values = + new HashMap<>(); + + for (int index = 0; + index < args.length; + index += 2) { + values.put( + args[index], + args[index + 1]); + } + + return new Arguments( + required( + values, + "--trino-version"), + Path.of( + required( + values, + "--roots")), + Path.of( + required( + values, + "--output"))); + } + + private static String required( + Map values, + String name) + { + String value = + values.get(name); + + if (value == null + || value.isBlank()) { + throw new IllegalArgumentException( + "Missing required argument: " + + name); + } + + return value; + } + } +} \ No newline at end of file diff --git a/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/ModelSchema.java b/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/ModelSchema.java new file mode 100644 index 00000000..ebfe4cbd --- /dev/null +++ b/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/ModelSchema.java @@ -0,0 +1,176 @@ +package org.trinoruby.modelgen; + +import com.fasterxml.jackson.annotation.JsonInclude; + +import java.util.List; + +@JsonInclude(JsonInclude.Include.NON_NULL) +public record ModelSchema( + int schemaVersion, + String trinoVersion, + List roots, + List models) +{ + @JsonInclude(JsonInclude.Include.NON_NULL) + public record ModelDefinition( + String javaName, + String simpleName, + String kind, + List properties) + { + } + + @JsonInclude(JsonInclude.Include.NON_NULL) + public record PropertyDefinition( + String jsonName, + String javaName, + Integer creatorIndex, + String nullability, + TypeDefinition type) + { + } + + /** + * kind: + * + * primitive + * opaque + * enum + * model + * value + * optional + * list + * set + * array + * map + */ + @JsonInclude(JsonInclude.Include.NON_NULL) + public record TypeDefinition( + String kind, + String name, + TypeDefinition elementType, + TypeDefinition keyType, + TypeDefinition valueType, + List enumValues) + { + public static TypeDefinition primitive(String name) + { + return new TypeDefinition( + "primitive", + name, + null, + null, + null, + null); + } + + public static TypeDefinition opaque(String name) + { + return new TypeDefinition( + "opaque", + name, + null, + null, + null, + null); + } + + public static TypeDefinition model(String name) + { + return new TypeDefinition( + "model", + name, + null, + null, + null, + null); + } + + public static TypeDefinition enumType( + String name, + List values) + { + return new TypeDefinition( + "enum", + name, + null, + null, + null, + List.copyOf(values)); + } + + public static TypeDefinition optional( + TypeDefinition elementType) + { + return new TypeDefinition( + "optional", + null, + elementType, + null, + null, + null); + } + + public static TypeDefinition list( + TypeDefinition elementType) + { + return new TypeDefinition( + "list", + null, + elementType, + null, + null, + null); + } + + public static TypeDefinition set( + TypeDefinition elementType) + { + return new TypeDefinition( + "set", + null, + elementType, + null, + null, + null); + } + + public static TypeDefinition array( + TypeDefinition elementType) + { + return new TypeDefinition( + "array", + null, + elementType, + null, + null, + null); + } + + public static TypeDefinition map( + TypeDefinition keyType, + TypeDefinition valueType) + { + return new TypeDefinition( + "map", + null, + null, + keyType, + valueType, + null); + } + + public static TypeDefinition value( + String name, + TypeDefinition valueType) + { + return new TypeDefinition( + "value", + name, + valueType, + null, + null, + null); + } + } +} \ No newline at end of file diff --git a/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/TypeClassifier.java b/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/TypeClassifier.java new file mode 100644 index 00000000..c8a8286d --- /dev/null +++ b/modelgen/java-extractor/src/main/java/org/trinoruby/modelgen/TypeClassifier.java @@ -0,0 +1,400 @@ +package org.trinoruby.modelgen; + +import com.fasterxml.jackson.annotation.JsonValue; +import com.fasterxml.jackson.databind.JavaType; +import com.fasterxml.jackson.databind.type.TypeFactory; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.OptionalLong; +import java.util.Set; + +import static org.trinoruby.modelgen.ModelSchema.TypeDefinition; + +public final class TypeClassifier +{ + private final TypeFactory typeFactory; + + public TypeClassifier( + TypeFactory typeFactory) + { + this.typeFactory = typeFactory; + } + + public Classification classify(JavaType type) + { + Class rawClass = type.getRawClass(); + String className = rawClass.getName(); + + /* + * Primitive and Wrapper for primitive. + */ + if (rawClass.isPrimitive() + || isPrimitiveWrapper(rawClass)) { + return Classification.withoutModels( + TypeDefinition.primitive(className)); + } + + /* + * Optional. + */ + if (rawClass == Optional.class) { + Classification element = classify( + requireElementType(type)); + + return new Classification( + TypeDefinition.optional(element.type()), + element.referencedModels()); + } + + if (rawClass == OptionalInt.class) { + return Classification.withoutModels( + TypeDefinition.optional( + TypeDefinition.primitive( + Integer.class.getName()))); + } + + if (rawClass == OptionalLong.class) { + return Classification.withoutModels( + TypeDefinition.optional( + TypeDefinition.primitive( + Long.class.getName()))); + } + + if (rawClass == OptionalDouble.class) { + return Classification.withoutModels( + TypeDefinition.optional( + TypeDefinition.primitive( + Double.class.getName()))); + } + + /* + * Array. + */ + if (rawClass.isArray()) { + Classification element = classify( + requireElementType(type)); + + return new Classification( + TypeDefinition.array(element.type()), + element.referencedModels()); + } + + /* + * Map. + */ + if (Map.class.isAssignableFrom(rawClass)) { + Classification key = classify( + requireMapKeyType(type)); + + Classification value = classify( + requireMapValueType(type)); + + return new Classification( + TypeDefinition.map( + key.type(), + value.type()), + union( + key.referencedModels(), + value.referencedModels())); + } + + /* + * Set. + */ + if (Set.class.isAssignableFrom(rawClass)) { + Classification element = classify( + requireElementType(type)); + + return new Classification( + TypeDefinition.set(element.type()), + element.referencedModels()); + } + + /* + * List and something. + */ + if (Collection.class.isAssignableFrom(rawClass)) { + Classification element = classify( + requireElementType(type)); + + return new Classification( + TypeDefinition.list(element.type()), + element.referencedModels()); + } + + /* + * Enum. + */ + if (rawClass.isEnum()) { + List values = + Arrays.stream(rawClass.getEnumConstants()) + .map(Object::toString) + .toList(); + + return Classification.withoutModels( + TypeDefinition.enumType( + className, + values)); + } + + /* + * value object with @JsonValue + * + * TransactionId: + * TransactionId -> String + * + * ResourceGroupId: + * ResourceGroupId -> List + * + */ + JavaType jsonValueType = + findJsonValueType(rawClass); + + if (jsonValueType != null) { + if (jsonValueType.getRawClass() == rawClass) { + throw new IllegalStateException( + "@JsonValue recursively refers to its own type: " + + className); + } + + Classification wireClassification = + classify(jsonValueType); + + return new Classification( + TypeDefinition.value( + className, + wireClassification.type()), + wireClassification.referencedModels()); + } + + /* + * Do not analyze the internal structure of interfaces or abstract classes. + * + */ + if (rawClass.isInterface() + || Modifier.isAbstract( + rawClass.getModifiers())) { + return Classification.withoutModels( + TypeDefinition.opaque(className)); + } + + /* + * Do not analyze the internal structure of types external to Trino. + * + * URI, Instant, Locale, DataSize and so on. + */ + if (!isTrinoModel(rawClass)) { + return Classification.withoutModels( + TypeDefinition.opaque(className)); + } + + /* + * Recursively analyze concrete Trino classes and records as regular models. + */ + return new Classification( + TypeDefinition.model(className), + Set.of(rawClass)); + } + + private JavaType findJsonValueType(Class type) + { + List jsonValueTypes = + new ArrayList<>(); + + /* + * Include inherited public methods in the analysis. + */ + for (Method method : type.getMethods()) { + JsonValue annotation = + method.getAnnotation(JsonValue.class); + + if (annotation == null + || !annotation.value()) { + continue; + } + + if (method.getParameterCount() != 0) { + throw new IllegalStateException( + "@JsonValue method must not have parameters: " + + type.getName() + + "#" + + method.getName()); + } + + jsonValueTypes.add( + typeFactory.constructType( + method.getGenericReturnType())); + } + + /* + * “Also check cases where a field is annotated with @JsonValue. + */ + for (Field field : type.getDeclaredFields()) { + JsonValue annotation = + field.getAnnotation(JsonValue.class); + + if (annotation == null + || !annotation.value()) { + continue; + } + + jsonValueTypes.add( + typeFactory.constructType( + field.getGenericType())); + } + + if (jsonValueTypes.isEmpty()) { + return null; + } + + if (jsonValueTypes.size() > 1) { + throw new IllegalStateException( + "Multiple active @JsonValue members found: " + + type.getName()); + } + + return jsonValueTypes.getFirst(); + } + + private static boolean isPrimitiveWrapper(Class type) + { + return type == String.class + || type == Boolean.class + || type == Byte.class + || type == Short.class + || type == Integer.class + || type == Long.class + || type == Float.class + || type == Double.class + || type == Character.class; + } + + private static boolean isTrinoModel(Class type) + { + String packageName = + type.getPackageName(); + + return packageName.equals("io.trino") + || packageName.startsWith("io.trino."); + } + + private static JavaType requireElementType( + JavaType type) + { + JavaType elementType = + type.getContentType(); + + /* + * For some JavaTypes, such as Optional, the content type can be obtained from containedType(0) even when getContentType() returns null. + */ + if (elementType == null + && type.containedTypeCount() >= 1) { + elementType = type.containedType(0); + } + + if (elementType == null) { + throw new IllegalArgumentException( + "Type does not have an element type: " + + type.toCanonical() + + " [javaTypeClass=" + + type.getClass().getName() + + ", containedTypeCount=" + + type.containedTypeCount() + + "]"); + } + + return elementType; + } + + private static JavaType requireMapKeyType( + JavaType type) + { + JavaType keyType = + type.getKeyType(); + + if (keyType == null + && type.containedTypeCount() >= 1) { + keyType = type.containedType(0); + } + + if (keyType == null) { + throw new IllegalArgumentException( + "Map type does not have a key type: " + + type.toCanonical() + + " [javaTypeClass=" + + type.getClass().getName() + + ", containedTypeCount=" + + type.containedTypeCount() + + "]"); + } + + return keyType; + } + + private static JavaType requireMapValueType( + JavaType type) + { + JavaType valueType = + type.getContentType(); + + if (valueType == null + && type.containedTypeCount() >= 2) { + valueType = type.containedType(1); + } + + if (valueType == null) { + throw new IllegalArgumentException( + "Map type does not have a value type: " + + type.toCanonical() + + " [javaTypeClass=" + + type.getClass().getName() + + ", containedTypeCount=" + + type.containedTypeCount() + + "]"); + } + + return valueType; + } + + private static Set> union( + Set> first, + Set> second) + { + Set> result = + new HashSet<>(first); + + result.addAll(second); + + return Set.copyOf(result); + } + + public record Classification( + TypeDefinition type, + Set> referencedModels) + { + public Classification + { + referencedModels = + Set.copyOf(referencedModels); + } + + public static Classification withoutModels( + TypeDefinition type) + { + return new Classification( + type, + Set.of()); + } + } +} \ No newline at end of file diff --git a/modelgen/java-extractor/src/test/java/org/trinoruby/modelgen/ParameterNamesModuleTest.java b/modelgen/java-extractor/src/test/java/org/trinoruby/modelgen/ParameterNamesModuleTest.java new file mode 100644 index 00000000..873cba8f --- /dev/null +++ b/modelgen/java-extractor/src/test/java/org/trinoruby/modelgen/ParameterNamesModuleTest.java @@ -0,0 +1,63 @@ +package org.trinoruby.modelgen; + +import com.fasterxml.jackson.databind.BeanDescription; +import com.fasterxml.jackson.databind.JavaType; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition; +import io.trino.spi.eventlistener.TableInfo; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class ParameterNamesModuleTest +{ + private final ObjectMapper objectMapper = + ModelExtractor.createObjectMapper(); + + @Test + void recognizesTableInfoConstructorProperties() + { + JavaType type = + objectMapper + .getTypeFactory() + .constructType( + TableInfo.class); + + BeanDescription description = + objectMapper + .getDeserializationConfig() + .introspect(type); + + List constructorProperties = + description.findProperties().stream() + .filter(property -> + property + .getConstructorParameter() + != null) + .toList(); + + Set propertyNames = + constructorProperties.stream() + .map( + BeanPropertyDefinition::getName) + .collect( + Collectors.toSet()); + + assertEquals( + Set.of( + "catalog", + "schema", + "table", + "authorization", + "filters", + "columns", + "directlyReferenced", + "viewText", + "referenceChain"), + propertyNames); + } +} diff --git a/modelgen/java-extractor/src/test/java/org/trinoruby/modelgen/TypeClassifierTest.java b/modelgen/java-extractor/src/test/java/org/trinoruby/modelgen/TypeClassifierTest.java new file mode 100644 index 00000000..e1d7d154 --- /dev/null +++ b/modelgen/java-extractor/src/test/java/org/trinoruby/modelgen/TypeClassifierTest.java @@ -0,0 +1,184 @@ +package org.trinoruby.modelgen; + +import com.fasterxml.jackson.databind.JavaType; +import com.fasterxml.jackson.databind.ObjectMapper; +import io.opentelemetry.api.trace.Span; +import io.trino.client.QueryData; +import io.trino.spi.resourcegroups.ResourceGroupId; +import io.trino.transaction.TransactionId; +import org.junit.jupiter.api.Test; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class TypeClassifierTest +{ + private final ObjectMapper objectMapper = + ModelExtractor.createObjectMapper(); + + private final TypeClassifier classifier = + new TypeClassifier( + objectMapper.getTypeFactory()); + + @Test + void classifiesOptionalString() + { + JavaType type = + objectMapper + .getTypeFactory() + .constructParametricType( + Optional.class, + String.class); + + TypeClassifier.Classification result = + classifier.classify(type); + + assertEquals( + "optional", + result.type().kind()); + + assertEquals( + "primitive", + result.type() + .elementType() + .kind()); + + assertEquals( + String.class.getName(), + result.type() + .elementType() + .name()); + + assertTrue( + result.referencedModels().isEmpty()); + } + + @Test + void classifiesTransactionIdUsingJsonValue() + { + JavaType type = + objectMapper + .getTypeFactory() + .constructType( + TransactionId.class); + + TypeClassifier.Classification result = + classifier.classify(type); + + assertEquals( + "value", + result.type().kind()); + + assertEquals( + TransactionId.class.getName(), + result.type().name()); + + + ModelSchema.TypeDefinition wireType = + result.type().elementType(); + + assertEquals( + "primitive", + wireType.kind()); + + assertEquals( + String.class.getName(), + wireType.name()); + + assertTrue( + result.referencedModels().isEmpty()); + } + + @Test + void classifiesResourceGroupIdUsingJsonValue() + { + JavaType type = + objectMapper + .getTypeFactory() + .constructType( + ResourceGroupId.class); + + TypeClassifier.Classification result = + classifier.classify(type); + + assertEquals( + "value", + result.type().kind()); + + assertEquals( + ResourceGroupId.class.getName(), + result.type().name()); + + + ModelSchema.TypeDefinition wireType = + result.type().elementType(); + + assertEquals( + "list", + wireType.kind()); + + ModelSchema.TypeDefinition elementType = + wireType.elementType(); + + assertEquals( + "primitive", + elementType.kind()); + + assertEquals( + String.class.getName(), + elementType.name()); + + assertTrue( + result.referencedModels().isEmpty()); + } + + @Test + void classifiesQueryDataAsOpaque() + { + JavaType type = + objectMapper + .getTypeFactory() + .constructType( + QueryData.class); + + TypeClassifier.Classification result = + classifier.classify(type); + + assertEquals( + "opaque", + result.type().kind()); + + assertEquals( + QueryData.class.getName(), + result.type().name()); + + assertTrue( + result.referencedModels().isEmpty()); + } + + @Test + void classifiesSpanAsOpaque() + { + JavaType type = + objectMapper + .getTypeFactory() + .constructType( + Span.class); + + TypeClassifier.Classification result = + classifier.classify(type); + + assertEquals( + "opaque", + result.type().kind()); + + assertEquals( + Span.class.getName(), + result.type().name()); + + assertTrue( + result.referencedModels().isEmpty()); + } +} \ No newline at end of file diff --git a/modelgen/schema_formatter.rb b/modelgen/schema_formatter.rb new file mode 100644 index 00000000..bffc9aca --- /dev/null +++ b/modelgen/schema_formatter.rb @@ -0,0 +1,302 @@ +# frozen_string_literal: true + +require "set" + +module TrinoModels + # Converts the JSON intermediate representation produced by the Java + # extractor into Ruby model definitions embedded by model_versions.rb. + class SchemaFormatter + PREDEFINED_MODELS = Set.new( + %w[ + DistributionSnapshot + PlanNode + EquiJoinClause + WriterTarget + WriteStatisticsTarget + OperatorInfo + HashCollisionsInfo + ] + ).freeze + + PREDEFINED_SIMPLE_CLASSES = Set.new( + %w[ + StageId + TaskId + Lifespan + ConnectorSession + ResourceGroupId + ] + ).freeze + + # Preserve existing trino-client-ruby names where Java packages contain + # classes with the same simple name. + MODEL_ALIASES = { + "io.trino.client.Column" => "ClientColumn", + "io.trino.execution.Column" => "Column", + "io.trino.client.StageStats" => "ClientStageStats", + "io.trino.execution.StageStats" => "StageStats", + "io.trino.execution.TableInfo" => "TableInfo", + "io.trino.spi.eventlistener.TableInfo" => "EventListenerTableInfo", + "io.trino.sql.planner.plan.StatisticAggregationsDescriptor" => "StatisticAggregationsDescriptor_Symbol" + }.freeze + + # Preserve wrappers that are part of the existing Ruby API. Other + # @JsonValue-backed Java types are represented by their wire values. + VALUE_WRAPPERS = { + "io.trino.spi.resourcegroups.ResourceGroupId" => "ResourceGroupId" + }.freeze + + SUPPORTED_SCHEMA_VERSIONS = [1].freeze + + LEGACY_EXTRA_PROPERTIES = { + "351" => { + "io.trino.execution.QueryInfo" => [ + { + "jsonName" => "finalQueryInfo", + "javaName" => "finalQueryInfo", + "creatorIndex" => 10_000, + "nullability" => "non_null", + "type" => { + "kind" => "primitive", + "name" => "boolean" + } + } + ] + } + }.freeze + + def initialize(schema) + @schema = schema + validate_schema! + + @models_by_java_name = @schema.fetch("models").each_with_object({}) do |model, result| + result[model.fetch("javaName")] = model + end + + validate_generated_name_uniqueness! + end + + def format + models = @schema.fetch("models") + .reject { |model| predefined_model?(ruby_model_name(model.fetch("javaName"))) } + .sort_by { |model| ruby_model_name(model.fetch("javaName")) } + + models.map { |model| format_model(model) }.join("\n") + end + + private + + def validate_schema! + schema_version = @schema.fetch("schemaVersion") + return if SUPPORTED_SCHEMA_VERSIONS.include?(schema_version) + + raise ArgumentError, + "Unsupported schemaVersion: #{schema_version.inspect}; " \ + "supported versions: #{SUPPORTED_SCHEMA_VERSIONS.inspect}" + end + + def validate_generated_name_uniqueness! + generated_models = @schema + .fetch("models") + .reject do |model| + generated_name = ruby_model_name( + model.fetch("javaName") + ) + + predefined_model?(generated_name) + end + + grouped = generated_models.group_by do |model| + ruby_model_name( + model.fetch("javaName") + ) + end + + duplicates = grouped.select do |_name, models| + models.length > 1 + end + + return if duplicates.empty? + + details = duplicates.map do |name, models| + java_names = models.map do |model| + model.fetch("javaName") + end + + "#{name}: #{java_names.join(', ')}" + end + + raise ArgumentError, + "Duplicate generated Ruby model names:\n" \ + "#{details.join("\n")}" + end + + def predefined_model?(name) + PREDEFINED_MODELS.include?(name) || PREDEFINED_SIMPLE_CLASSES.include?(name) + end + + def format_model(model) + name = ruby_model_name(model.fetch("javaName")) + validate_ruby_constant_name!(name, model.fetch("javaName")) + + properties = properties_for(model) + members = properties.map do |property| + ":#{ruby_property_name(property.fetch("jsonName"))}" + end + + lines = [] + lines << " class << #{name} =" + lines << if members.empty? + " Base.new()" + else + " Base.new(#{members.join(', ')})" + end + lines << " def decode(hash)" + lines << " unless hash.is_a?(Hash)" + lines << %q( raise TypeError, "Can't convert #{hash.class} to Hash") + lines << " end" + lines << " obj = allocate" + lines << " obj.send(:initialize_struct," + + properties.each do |property| + json_name = property.fetch("jsonName") + source_expression = "hash[#{json_name.dump}]" + decoded_expression = decode_expression(property.fetch("type"), source_expression) + lines << " #{decoded_expression}," + end + + lines << " )" + lines << " obj" + lines << " end" + lines << " end" + lines << "" + lines.join("\n") + end + + def properties_for(model) + properties = model + .fetch("properties") + .map(&:dup) + + trino_version = @schema.fetch( + "trinoVersion" + ) + + java_name = model.fetch( + "javaName" + ) + + version_overrides = + LEGACY_EXTRA_PROPERTIES.fetch( + trino_version, + {} + ) + + extras = version_overrides.fetch( + java_name, + [] + ) + + existing_names = properties.map do |property| + property.fetch("jsonName") + end + + extras.each do |property| + json_name = property.fetch( + "jsonName" + ) + + next if existing_names.include?( + json_name + ) + + properties << property + existing_names << json_name + end + + properties + end + + def decode_expression(type, expression) + kind = type.fetch("kind") + + case kind + when "primitive", "opaque" + expression + when "enum" + nil_guard(expression, "#{expression}.downcase.to_sym") + when "model" + model_name = ruby_model_name(type.fetch("name")) + nil_guard(expression, "#{model_name}.decode(#{expression})") + when "value" + decode_value_type(type, expression) + when "optional" + decode_expression(type.fetch("elementType"), expression) + when "list", "set", "array" + decode_array_type(type, expression) + when "map" + decode_map_type(type, expression) + else + raise ArgumentError, "Unsupported schema type: #{kind.inspect}" + end + end + + def decode_value_type(type, expression) + java_name = type.fetch("name") + wire_expression = decode_expression(type.fetch("elementType"), expression) + wrapper = VALUE_WRAPPERS[java_name] + + return wire_expression if wrapper.nil? + + nil_guard(expression, "#{wrapper}.new(#{wire_expression})") + end + + def decode_array_type(type, expression) + element_expression = decode_expression(type.fetch("elementType"), "element") + decoded = "#{expression}.map { |element| #{element_expression} }" + nil_guard(expression, decoded) + end + + def decode_map_type(type, expression) + key_expression = decode_expression(type.fetch("keyType"), "key") + value_expression = decode_expression(type.fetch("valueType"), "map_value") + decoded = "Hash[#{expression}.to_a.map { |key, map_value| " \ + "[#{key_expression}, #{value_expression}] }]" + nil_guard(expression, decoded) + end + + def nil_guard(expression, decoded_expression) + "(#{expression}.nil? ? nil : #{decoded_expression})" + end + + def ruby_model_name(java_name) + aliased_name = MODEL_ALIASES[java_name] + return aliased_name unless aliased_name.nil? + + model = @models_by_java_name[java_name] + return model.fetch("simpleName") unless model.nil? + + java_name.split(".").last.split("$").last + end + + def validate_ruby_constant_name!(name, java_name) + return if name.match?(/\A[A-Z][A-Za-z0-9_]*\z/) + + raise ArgumentError, + "Invalid generated Ruby constant #{name.inspect} for #{java_name.inspect}" + end + + def ruby_property_name(json_name) + name = json_name.gsub(/[A-Z]/) do |character| + "_#{character.downcase}" + end + + unless name.match?(/\A[a-z_][A-Za-z0-9_]*\z/) + raise ArgumentError, + "Invalid generated Ruby member #{name.inspect} from JSON property #{json_name.inspect}" + end + + name + end + end +end \ No newline at end of file diff --git a/modelgen/schemas/351.json b/modelgen/schemas/351.json new file mode 100644 index 00000000..6eb3968c --- /dev/null +++ b/modelgen/schemas/351.json @@ -0,0 +1,10690 @@ +{ + "schemaVersion" : 1, + "trinoVersion" : "351", + "roots" : [ "io.trino.client.QueryResults", "io.trino.execution.QueryInfo", "io.trino.server.BasicQueryInfo", "io.trino.sql.planner.plan.OutputNode", "io.trino.sql.planner.plan.ProjectNode", "io.trino.sql.planner.plan.TableScanNode", "io.trino.sql.planner.plan.ValuesNode", "io.trino.sql.planner.plan.AggregationNode", "io.trino.sql.planner.plan.MarkDistinctNode", "io.trino.sql.planner.plan.FilterNode", "io.trino.sql.planner.plan.WindowNode", "io.trino.sql.planner.plan.RowNumberNode", "io.trino.sql.planner.plan.TopNRowNumberNode", "io.trino.sql.planner.plan.LimitNode", "io.trino.sql.planner.plan.DistinctLimitNode", "io.trino.sql.planner.plan.TopNNode", "io.trino.sql.planner.plan.SampleNode", "io.trino.sql.planner.plan.SortNode", "io.trino.sql.planner.plan.RemoteSourceNode", "io.trino.sql.planner.plan.JoinNode", "io.trino.sql.planner.plan.SemiJoinNode", "io.trino.sql.planner.plan.SpatialJoinNode", "io.trino.sql.planner.plan.IndexJoinNode", "io.trino.sql.planner.plan.IndexSourceNode", "io.trino.sql.planner.plan.TableWriterNode", "io.trino.sql.planner.plan.DeleteNode", "io.trino.sql.planner.plan.TableFinishNode", "io.trino.sql.planner.plan.UnnestNode", "io.trino.sql.planner.plan.ExchangeNode", "io.trino.sql.planner.plan.UnionNode", "io.trino.sql.planner.plan.IntersectNode", "io.trino.sql.planner.plan.EnforceSingleRowNode", "io.trino.sql.planner.plan.GroupIdNode", "io.trino.sql.planner.plan.ExplainAnalyzeNode", "io.trino.sql.planner.plan.ApplyNode", "io.trino.sql.planner.plan.AssignUniqueId", "io.trino.sql.planner.plan.CorrelatedJoinNode", "io.trino.sql.planner.plan.StatisticsWriterNode", "io.trino.metadata.AnalyzeTableHandle", "io.trino.metadata.InsertTableHandle", "io.trino.metadata.OutputTableHandle", "io.trino.operator.ExchangeClientStatus", "io.trino.operator.JoinOperatorInfo", "io.trino.operator.PageBufferClientStatus", "io.trino.operator.PartitionedOutputOperator$PartitionedOutputInfo", "io.trino.operator.SplitOperatorInfo", "io.trino.operator.TableFinishInfo", "io.trino.operator.TableWriterOperator$TableWriterInfo", "io.trino.operator.WindowInfo", "io.trino.operator.WindowInfo$DriverWindowInfo", "io.trino.operator.exchange.LocalExchangeBufferInfo", "io.trino.sql.planner.plan.StatisticsWriterNode$WriteStatisticsHandle", "io.trino.sql.planner.plan.TableWriterNode$CreateTarget", "io.trino.sql.planner.plan.TableWriterNode$InsertTarget", "io.trino.sql.planner.plan.TableWriterNode$RefreshMaterializedViewTarget" ], + "models" : [ { + "javaName" : "io.trino.SessionRepresentation", + "simpleName" : "SessionRepresentation", + "kind" : "class", + "properties" : [ { + "jsonName" : "queryId", + "javaName" : "queryId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "transactionId", + "javaName" : "transactionId", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.transaction.TransactionId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "clientTransactionSupport", + "javaName" : "clientTransactionSupport", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "user", + "javaName" : "user", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "groups", + "javaName" : "groups", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "principal", + "javaName" : "principal", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "catalog", + "javaName" : "catalog", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "path", + "javaName" : "path", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.SqlPath" + } + }, { + "jsonName" : "traceToken", + "javaName" : "traceToken", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "timeZoneKey", + "javaName" : "timeZoneKey", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.TimeZoneKey", + "elementType" : { + "kind" : "primitive", + "name" : "short" + } + } + }, { + "jsonName" : "locale", + "javaName" : "locale", + "creatorIndex" : 12, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.util.Locale" + } + }, { + "jsonName" : "remoteUserAddress", + "javaName" : "remoteUserAddress", + "creatorIndex" : 13, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "userAgent", + "javaName" : "userAgent", + "creatorIndex" : 14, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "clientInfo", + "javaName" : "clientInfo", + "creatorIndex" : 15, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "clientTags", + "javaName" : "clientTags", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "clientCapabilities", + "javaName" : "clientCapabilities", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "resourceEstimates", + "javaName" : "resourceEstimates", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.session.ResourceEstimates" + } + }, { + "jsonName" : "start", + "javaName" : "start", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "systemProperties", + "javaName" : "systemProperties", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "catalogProperties", + "javaName" : "catalogProperties", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "unprocessedCatalogProperties", + "javaName" : "unprocessedCatalogProperties", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "roles", + "javaName" : "roles", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.spi.security.SelectedRole" + } + } + }, { + "jsonName" : "preparedStatements", + "javaName" : "preparedStatements", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "protocolName", + "javaName" : "protocolName", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.client.ClientTypeSignature", + "simpleName" : "ClientTypeSignature", + "kind" : "class", + "properties" : [ { + "jsonName" : "rawType", + "javaName" : "rawType", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "arguments", + "javaName" : "arguments", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.ClientTypeSignatureParameter" + } + } + } ] + }, { + "javaName" : "io.trino.client.ClientTypeSignatureParameter", + "simpleName" : "ClientTypeSignatureParameter", + "kind" : "class", + "properties" : [ { + "jsonName" : "kind", + "javaName" : "kind", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.client.ClientTypeSignatureParameter$ParameterKind", + "enumValues" : [ "TYPE", "NAMED_TYPE", "LONG", "VARIABLE" ] + } + }, { + "jsonName" : "value", + "javaName" : "value", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } ] + }, { + "javaName" : "io.trino.client.Column", + "simpleName" : "Column", + "kind" : "class", + "properties" : [ { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "typeSignature", + "javaName" : "typeSignature", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ClientTypeSignature" + } + } ] + }, { + "javaName" : "io.trino.client.ErrorLocation", + "simpleName" : "ErrorLocation", + "kind" : "class", + "properties" : [ { + "jsonName" : "lineNumber", + "javaName" : "lineNumber", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "columnNumber", + "javaName" : "columnNumber", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.client.FailureInfo", + "simpleName" : "FailureInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "cause", + "javaName" : "cause", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.FailureInfo" + } + }, { + "jsonName" : "suppressed", + "javaName" : "suppressed", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.FailureInfo" + } + } + }, { + "jsonName" : "stack", + "javaName" : "stack", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "errorLocation", + "javaName" : "errorLocation", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ErrorLocation" + } + } ] + }, { + "javaName" : "io.trino.client.QueryError", + "simpleName" : "QueryError", + "kind" : "class", + "properties" : [ { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "sqlState", + "javaName" : "sqlState", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "errorCode", + "javaName" : "errorCode", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "errorName", + "javaName" : "errorName", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "errorType", + "javaName" : "errorType", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "errorLocation", + "javaName" : "errorLocation", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ErrorLocation" + } + }, { + "jsonName" : "failureInfo", + "javaName" : "failureInfo", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.FailureInfo" + } + } ] + }, { + "javaName" : "io.trino.client.QueryResults", + "simpleName" : "QueryResults", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "infoUri", + "javaName" : "infoUri", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "partialCancelUri", + "javaName" : "partialCancelUri", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "nextUri", + "javaName" : "nextUri", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.Column" + } + } + }, { + "jsonName" : "data", + "javaName" : "data", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + } + }, { + "jsonName" : "stats", + "javaName" : "stats", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.client.StatementStats" + } + }, { + "jsonName" : "error", + "javaName" : "error", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.QueryError" + } + }, { + "jsonName" : "warnings", + "javaName" : "warnings", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.Warning" + } + } + }, { + "jsonName" : "updateType", + "javaName" : "updateType", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "updateCount", + "javaName" : "updateCount", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.Long" + } + } ] + }, { + "javaName" : "io.trino.client.StageStats", + "simpleName" : "StageStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "stageId", + "javaName" : "stageId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "done", + "javaName" : "done", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "nodes", + "javaName" : "nodes", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalSplits", + "javaName" : "totalSplits", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedSplits", + "javaName" : "queuedSplits", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningSplits", + "javaName" : "runningSplits", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedSplits", + "javaName" : "completedSplits", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cpuTimeMillis", + "javaName" : "cpuTimeMillis", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "wallTimeMillis", + "javaName" : "wallTimeMillis", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedRows", + "javaName" : "processedRows", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedBytes", + "javaName" : "processedBytes", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputBytes", + "javaName" : "physicalInputBytes", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "subStages", + "javaName" : "subStages", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.StageStats" + } + } + } ] + }, { + "javaName" : "io.trino.client.StatementStats", + "simpleName" : "StatementStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "queued", + "javaName" : "queued", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "scheduled", + "javaName" : "scheduled", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "nodes", + "javaName" : "nodes", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalSplits", + "javaName" : "totalSplits", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedSplits", + "javaName" : "queuedSplits", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningSplits", + "javaName" : "runningSplits", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedSplits", + "javaName" : "completedSplits", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cpuTimeMillis", + "javaName" : "cpuTimeMillis", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "wallTimeMillis", + "javaName" : "wallTimeMillis", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "queuedTimeMillis", + "javaName" : "queuedTimeMillis", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "elapsedTimeMillis", + "javaName" : "elapsedTimeMillis", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedRows", + "javaName" : "processedRows", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedBytes", + "javaName" : "processedBytes", + "creatorIndex" : 13, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputBytes", + "javaName" : "physicalInputBytes", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "peakMemoryBytes", + "javaName" : "peakMemoryBytes", + "creatorIndex" : 15, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "spilledBytes", + "javaName" : "spilledBytes", + "creatorIndex" : 16, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rootStage", + "javaName" : "rootStage", + "creatorIndex" : 17, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.StageStats" + } + } ] + }, { + "javaName" : "io.trino.client.Warning", + "simpleName" : "Warning", + "kind" : "class", + "properties" : [ { + "jsonName" : "warningCode", + "javaName" : "warningCode", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.client.Warning$Code" + } + }, { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.client.Warning$Code", + "simpleName" : "Code", + "kind" : "class", + "properties" : [ { + "jsonName" : "code", + "javaName" : "code", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.cost.LocalCostEstimate", + "simpleName" : "LocalCostEstimate", + "kind" : "class", + "properties" : [ { + "jsonName" : "cpuCost", + "javaName" : "cpuCost", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "maxMemory", + "javaName" : "maxMemory", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "networkCost", + "javaName" : "networkCost", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + } ] + }, { + "javaName" : "io.trino.cost.PlanCostEstimate", + "simpleName" : "PlanCostEstimate", + "kind" : "class", + "properties" : [ { + "jsonName" : "cpuCost", + "javaName" : "cpuCost", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "maxMemory", + "javaName" : "maxMemory", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "maxMemoryWhenOutputting", + "javaName" : "maxMemoryWhenOutputting", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "networkCost", + "javaName" : "networkCost", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "rootNodeLocalCostEstimate", + "javaName" : "rootNodeLocalCostEstimate", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.cost.LocalCostEstimate" + } + } ] + }, { + "javaName" : "io.trino.cost.PlanNodeStatsAndCostSummary", + "simpleName" : "PlanNodeStatsAndCostSummary", + "kind" : "class", + "properties" : [ { + "jsonName" : "outputRowCount", + "javaName" : "outputRowCount", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "outputSizeInBytes", + "javaName" : "outputSizeInBytes", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "cpuCost", + "javaName" : "cpuCost", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "memoryCost", + "javaName" : "memoryCost", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "networkCost", + "javaName" : "networkCost", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + } ] + }, { + "javaName" : "io.trino.cost.PlanNodeStatsEstimate", + "simpleName" : "PlanNodeStatsEstimate", + "kind" : "class", + "properties" : [ { + "jsonName" : "outputRowCount", + "javaName" : "outputRowCount", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "symbolStatistics", + "javaName" : "symbolStatistics", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.cost.SymbolStatsEstimate" + } + } + } ] + }, { + "javaName" : "io.trino.cost.StatsAndCosts", + "simpleName" : "StatsAndCosts", + "kind" : "class", + "properties" : [ { + "jsonName" : "stats", + "javaName" : "stats", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.cost.PlanNodeStatsEstimate" + } + } + }, { + "jsonName" : "costs", + "javaName" : "costs", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.cost.PlanCostEstimate" + } + } + } ] + }, { + "javaName" : "io.trino.cost.SymbolStatsEstimate", + "simpleName" : "SymbolStatsEstimate", + "kind" : "class", + "properties" : [ { + "jsonName" : "lowValue", + "javaName" : "lowValue", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "highValue", + "javaName" : "highValue", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "nullsFraction", + "javaName" : "nullsFraction", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "averageRowSize", + "javaName" : "averageRowSize", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "distinctValuesCount", + "javaName" : "distinctValuesCount", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + } ] + }, { + "javaName" : "io.trino.execution.Column", + "simpleName" : "Column", + "kind" : "class", + "properties" : [ { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.execution.ExecutionFailureInfo", + "simpleName" : "ExecutionFailureInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "cause", + "javaName" : "cause", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + }, { + "jsonName" : "suppressed", + "javaName" : "suppressed", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + } + }, { + "jsonName" : "stack", + "javaName" : "stack", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "errorLocation", + "javaName" : "errorLocation", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ErrorLocation" + } + }, { + "jsonName" : "errorCode", + "javaName" : "errorCode", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.ErrorCode" + } + }, { + "jsonName" : "remoteHost", + "javaName" : "remoteHost", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.HostAddress", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.execution.Input", + "simpleName" : "Input", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "connectorInfo", + "javaName" : "connectorInfo", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.Column" + } + } + }, { + "jsonName" : "fragmentId", + "javaName" : "fragmentId", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanFragmentId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "planNodeId", + "javaName" : "planNodeId", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.execution.QueryInfo", + "simpleName" : "QueryInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "queryId", + "javaName" : "queryId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.QueryId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "session", + "javaName" : "session", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.SessionRepresentation" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.QueryState", + "enumValues" : [ "QUEUED", "WAITING_FOR_RESOURCES", "DISPATCHING", "PLANNING", "STARTING", "RUNNING", "FINISHING", "FINISHED", "FAILED" ] + } + }, { + "jsonName" : "memoryPool", + "javaName" : "memoryPool", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.memory.MemoryPoolId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "scheduled", + "javaName" : "scheduled", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "self", + "javaName" : "self", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "fieldNames", + "javaName" : "fieldNames", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "query", + "javaName" : "query", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "preparedQuery", + "javaName" : "preparedQuery", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queryStats", + "javaName" : "queryStats", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.QueryStats" + } + }, { + "jsonName" : "setCatalog", + "javaName" : "setCatalog", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "setSchema", + "javaName" : "setSchema", + "creatorIndex" : 11, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "setPath", + "javaName" : "setPath", + "creatorIndex" : 12, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "setSessionProperties", + "javaName" : "setSessionProperties", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "resetSessionProperties", + "javaName" : "resetSessionProperties", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "setRoles", + "javaName" : "setRoles", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.spi.security.SelectedRole" + } + } + }, { + "jsonName" : "addedPreparedStatements", + "javaName" : "addedPreparedStatements", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "deallocatedPreparedStatements", + "javaName" : "deallocatedPreparedStatements", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "startedTransactionId", + "javaName" : "startedTransactionId", + "creatorIndex" : 18, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.transaction.TransactionId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "clearTransactionId", + "javaName" : "clearTransactionId", + "creatorIndex" : 19, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "updateType", + "javaName" : "updateType", + "creatorIndex" : 20, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "outputStage", + "javaName" : "outputStage", + "creatorIndex" : 21, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.StageInfo" + } + } + }, { + "jsonName" : "failureInfo", + "javaName" : "failureInfo", + "creatorIndex" : 22, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + }, { + "jsonName" : "errorCode", + "javaName" : "errorCode", + "creatorIndex" : 23, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.ErrorCode" + } + }, { + "jsonName" : "warnings", + "javaName" : "warnings", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.TrinoWarning" + } + } + }, { + "jsonName" : "inputs", + "javaName" : "inputs", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.Input" + } + } + }, { + "jsonName" : "output", + "javaName" : "output", + "creatorIndex" : 26, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.analyzer.Output" + } + } + }, { + "jsonName" : "referencedTables", + "javaName" : "referencedTables", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.TableInfo" + } + } + }, { + "jsonName" : "routines", + "javaName" : "routines", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.RoutineInfo" + } + } + }, { + "jsonName" : "completeInfo", + "javaName" : "completeInfo", + "creatorIndex" : 29, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "resourceGroupId", + "javaName" : "resourceGroupId", + "creatorIndex" : 30, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.resourcegroups.ResourceGroupId", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "queryType", + "javaName" : "queryType", + "creatorIndex" : 31, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.spi.resourcegroups.QueryType", + "enumValues" : [ "DATA_DEFINITION", "DELETE", "DESCRIBE", "EXPLAIN", "ANALYZE", "INSERT", "SELECT" ] + } + } + } ] + }, { + "javaName" : "io.trino.execution.QueryStats", + "simpleName" : "QueryStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "createTime", + "javaName" : "createTime", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "executionStartTime", + "javaName" : "executionStartTime", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "lastHeartbeat", + "javaName" : "lastHeartbeat", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "endTime", + "javaName" : "endTime", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "resourceWaitingTime", + "javaName" : "resourceWaitingTime", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "dispatchingTime", + "javaName" : "dispatchingTime", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "executionTime", + "javaName" : "executionTime", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "analysisTime", + "javaName" : "analysisTime", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "planningTime", + "javaName" : "planningTime", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "finishingTime", + "javaName" : "finishingTime", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalTasks", + "javaName" : "totalTasks", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningTasks", + "javaName" : "runningTasks", + "creatorIndex" : 13, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedTasks", + "javaName" : "completedTasks", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 15, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 16, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 18, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 19, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cumulativeUserMemory", + "javaName" : "cumulativeUserMemory", + "creatorIndex" : 20, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalMemoryReservation", + "javaName" : "totalMemoryReservation", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakRevocableMemoryReservation", + "javaName" : "peakRevocableMemoryReservation", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakNonRevocableMemoryReservation", + "javaName" : "peakNonRevocableMemoryReservation", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTotalMemoryReservation", + "javaName" : "peakTotalMemoryReservation", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTaskUserMemory", + "javaName" : "peakTaskUserMemory", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTaskRevocableMemory", + "javaName" : "peakTaskRevocableMemory", + "creatorIndex" : 29, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTaskTotalMemory", + "javaName" : "peakTaskTotalMemory", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "scheduled", + "javaName" : "scheduled", + "creatorIndex" : 31, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 33, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 35, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 36, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 37, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 38, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 39, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 40, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 41, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rawInputDataSize", + "javaName" : "rawInputDataSize", + "creatorIndex" : 42, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "rawInputPositions", + "javaName" : "rawInputPositions", + "creatorIndex" : 43, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 44, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 45, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 46, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 47, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 48, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "stageGcStatistics", + "javaName" : "stageGcStatistics", + "creatorIndex" : 49, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.StageGcStatistics" + } + } + }, { + "jsonName" : "dynamicFiltersStats", + "javaName" : "dynamicFiltersStats", + "creatorIndex" : 50, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.server.DynamicFilterService$DynamicFiltersStats" + } + }, { + "jsonName" : "operatorSummaries", + "javaName" : "operatorSummaries", + "creatorIndex" : 51, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.OperatorStats" + } + } + } ] + }, { + "javaName" : "io.trino.execution.StageInfo", + "simpleName" : "StageInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "stageId", + "javaName" : "stageId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.execution.StageId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.StageState", + "enumValues" : [ "PLANNED", "SCHEDULING", "SCHEDULING_SPLITS", "SCHEDULED", "RUNNING", "FLUSHING", "FINISHED", "CANCELED", "ABORTED", "FAILED" ] + } + }, { + "jsonName" : "plan", + "javaName" : "plan", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PlanFragment" + } + }, { + "jsonName" : "types", + "javaName" : "types", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "stageStats", + "javaName" : "stageStats", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.StageStats" + } + }, { + "jsonName" : "tasks", + "javaName" : "tasks", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.TaskInfo" + } + } + }, { + "jsonName" : "subStages", + "javaName" : "subStages", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.StageInfo" + } + } + }, { + "jsonName" : "tables", + "javaName" : "tables", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.execution.TableInfo" + } + } + }, { + "jsonName" : "failureCause", + "javaName" : "failureCause", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + } ] + }, { + "javaName" : "io.trino.execution.StageStats", + "simpleName" : "StageStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "schedulingComplete", + "javaName" : "schedulingComplete", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "getSplitDistribution", + "javaName" : "getSplitDistribution", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.airlift.stats.Distribution$DistributionSnapshot" + } + }, { + "jsonName" : "totalTasks", + "javaName" : "totalTasks", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningTasks", + "javaName" : "runningTasks", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedTasks", + "javaName" : "completedTasks", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cumulativeUserMemory", + "javaName" : "cumulativeUserMemory", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 12, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalMemoryReservation", + "javaName" : "totalMemoryReservation", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakRevocableMemoryReservation", + "javaName" : "peakRevocableMemoryReservation", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 19, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 22, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 25, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rawInputDataSize", + "javaName" : "rawInputDataSize", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "rawInputPositions", + "javaName" : "rawInputPositions", + "creatorIndex" : 27, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 29, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "bufferedDataSize", + "javaName" : "bufferedDataSize", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 31, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 32, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 33, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "gcInfo", + "javaName" : "gcInfo", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.StageGcStatistics" + } + }, { + "jsonName" : "operatorSummaries", + "javaName" : "operatorSummaries", + "creatorIndex" : 35, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.OperatorStats" + } + } + } ] + }, { + "javaName" : "io.trino.execution.TableInfo", + "simpleName" : "TableInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "tableName", + "javaName" : "tableName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.metadata.QualifiedObjectName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "predicate", + "javaName" : "predicate", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.TupleDomain" + } + } ] + }, { + "javaName" : "io.trino.execution.TaskInfo", + "simpleName" : "TaskInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "taskStatus", + "javaName" : "taskStatus", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.TaskStatus" + } + }, { + "jsonName" : "lastHeartbeat", + "javaName" : "lastHeartbeat", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "outputBuffers", + "javaName" : "outputBuffers", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.buffer.OutputBufferInfo" + } + }, { + "jsonName" : "noMoreSplits", + "javaName" : "noMoreSplits", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "stats", + "javaName" : "stats", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.operator.TaskStats" + } + }, { + "jsonName" : "needsPlan", + "javaName" : "needsPlan", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.execution.TaskStatus", + "simpleName" : "TaskStatus", + "kind" : "class", + "properties" : [ { + "jsonName" : "taskId", + "javaName" : "taskId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.execution.TaskId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "taskInstanceId", + "javaName" : "taskInstanceId", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "version", + "javaName" : "version", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.TaskState", + "enumValues" : [ "PLANNED", "RUNNING", "FLUSHING", "FINISHED", "CANCELED", "ABORTED", "FAILED" ] + } + }, { + "jsonName" : "self", + "javaName" : "self", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "nodeId", + "javaName" : "nodeId", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "completedDriverGroups", + "javaName" : "completedDriverGroups", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "value", + "name" : "io.trino.execution.Lifespan", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "failures", + "javaName" : "failures", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + } + }, { + "jsonName" : "queuedPartitionedDrivers", + "javaName" : "queuedPartitionedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningPartitionedDrivers", + "javaName" : "runningPartitionedDrivers", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "outputBufferOverutilized", + "javaName" : "outputBufferOverutilized", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "memoryReservation", + "javaName" : "memoryReservation", + "creatorIndex" : 12, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "systemMemoryReservation", + "javaName" : "systemMemoryReservation", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullGcCount", + "javaName" : "fullGcCount", + "creatorIndex" : 15, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "fullGcTime", + "javaName" : "fullGcTime", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "dynamicFiltersVersion", + "javaName" : "dynamicFiltersVersion", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + } ] + }, { + "javaName" : "io.trino.execution.buffer.BufferInfo", + "simpleName" : "BufferInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "bufferId", + "javaName" : "bufferId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.execution.buffer.OutputBuffers$OutputBufferId", + "elementType" : { + "kind" : "primitive", + "name" : "int" + } + } + }, { + "jsonName" : "finished", + "javaName" : "finished", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "bufferedPages", + "javaName" : "bufferedPages", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "pagesSent", + "javaName" : "pagesSent", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "pageBufferInfo", + "javaName" : "pageBufferInfo", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.buffer.PageBufferInfo" + } + } ] + }, { + "javaName" : "io.trino.execution.buffer.OutputBufferInfo", + "simpleName" : "OutputBufferInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.buffer.BufferState", + "enumValues" : [ "OPEN", "NO_MORE_BUFFERS", "NO_MORE_PAGES", "FLUSHING", "FINISHED", "FAILED" ] + } + }, { + "jsonName" : "canAddBuffers", + "javaName" : "canAddBuffers", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "canAddPages", + "javaName" : "canAddPages", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "totalBufferedBytes", + "javaName" : "totalBufferedBytes", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalBufferedPages", + "javaName" : "totalBufferedPages", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalRowsSent", + "javaName" : "totalRowsSent", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalPagesSent", + "javaName" : "totalPagesSent", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "buffers", + "javaName" : "buffers", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.buffer.BufferInfo" + } + } + } ] + }, { + "javaName" : "io.trino.execution.buffer.PageBufferInfo", + "simpleName" : "PageBufferInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "partition", + "javaName" : "partition", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "bufferedPages", + "javaName" : "bufferedPages", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "bufferedBytes", + "javaName" : "bufferedBytes", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rowsAdded", + "javaName" : "rowsAdded", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "pagesAdded", + "javaName" : "pagesAdded", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + } ] + }, { + "javaName" : "io.trino.metadata.AnalyzeTableHandle", + "simpleName" : "AnalyzeTableHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTableHandle" + } + } ] + }, { + "javaName" : "io.trino.metadata.BoundSignature", + "simpleName" : "BoundSignature", + "kind" : "class", + "properties" : [ { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "returnType", + "javaName" : "returnType", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "argumentTypes", + "javaName" : "argumentTypes", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + } ] + }, { + "javaName" : "io.trino.metadata.IndexHandle", + "simpleName" : "IndexHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorIndexHandle" + } + } ] + }, { + "javaName" : "io.trino.metadata.InsertTableHandle", + "simpleName" : "InsertTableHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorInsertTableHandle" + } + } ] + }, { + "javaName" : "io.trino.metadata.OutputTableHandle", + "simpleName" : "OutputTableHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorOutputTableHandle" + } + } ] + }, { + "javaName" : "io.trino.metadata.ResolvedFunction", + "simpleName" : "ResolvedFunction", + "kind" : "class", + "properties" : [ { + "jsonName" : "signature", + "javaName" : "signature", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.BoundSignature" + } + }, { + "jsonName" : "id", + "javaName" : "functionId", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.metadata.FunctionId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "typeDependencies", + "javaName" : "typeDependencies", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeSignature", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "functionDependencies", + "javaName" : "functionDependencies", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.metadata.ResolvedFunction" + } + } + } ] + }, { + "javaName" : "io.trino.metadata.TableHandle", + "simpleName" : "TableHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTableHandle" + } + }, { + "jsonName" : "transaction", + "javaName" : "transaction", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "layout", + "javaName" : "layout", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTableLayoutHandle" + } + } + } ] + }, { + "javaName" : "io.trino.operator.DriverStats", + "simpleName" : "DriverStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "lifespan", + "javaName" : "lifespan", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.execution.Lifespan", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "createTime", + "javaName" : "createTime", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "startTime", + "javaName" : "startTime", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "endTime", + "javaName" : "endTime", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "systemMemoryReservation", + "javaName" : "systemMemoryReservation", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 15, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 18, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "internalNetworkInputReadTime", + "javaName" : "internalNetworkInputReadTime", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "rawInputDataSize", + "javaName" : "rawInputDataSize", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "rawInputPositions", + "javaName" : "rawInputPositions", + "creatorIndex" : 21, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rawInputReadTime", + "javaName" : "rawInputReadTime", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 24, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 26, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "operatorStats", + "javaName" : "operatorStats", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.OperatorStats" + } + } + } ] + }, { + "javaName" : "io.trino.operator.ExchangeClientStatus", + "simpleName" : "ExchangeClientStatus", + "kind" : "class", + "properties" : [ { + "jsonName" : "bufferedBytes", + "javaName" : "bufferedBytes", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "maxBufferedBytes", + "javaName" : "maxBufferedBytes", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "averageBytesPerRequest", + "javaName" : "averageBytesPerRequest", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "successfulRequestsCount", + "javaName" : "successfulRequestsCount", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "bufferedPages", + "javaName" : "bufferedPages", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "noMoreLocations", + "javaName" : "noMoreLocations", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "pageBufferClientStatuses", + "javaName" : "pageBufferClientStatuses", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.PageBufferClientStatus" + } + } + } ] + }, { + "javaName" : "io.trino.operator.JoinOperatorInfo", + "simpleName" : "JoinOperatorInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "joinType", + "javaName" : "joinType", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.operator.LookupJoinOperators$JoinType", + "enumValues" : [ "INNER", "PROBE_OUTER", "LOOKUP_OUTER", "FULL_OUTER" ] + } + }, { + "jsonName" : "logHistogramProbes", + "javaName" : "logHistogramProbes", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "array", + "elementType" : { + "kind" : "primitive", + "name" : "long" + } + } + }, { + "jsonName" : "logHistogramOutput", + "javaName" : "logHistogramOutput", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "array", + "elementType" : { + "kind" : "primitive", + "name" : "long" + } + } + }, { + "jsonName" : "lookupSourcePositions", + "javaName" : "lookupSourcePositions", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Long" + } + } + } ] + }, { + "javaName" : "io.trino.operator.OperatorStats", + "simpleName" : "OperatorStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "stageId", + "javaName" : "stageId", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "pipelineId", + "javaName" : "pipelineId", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "operatorId", + "javaName" : "operatorId", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "planNodeId", + "javaName" : "planNodeId", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "operatorType", + "javaName" : "operatorType", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "addInputCalls", + "javaName" : "addInputCalls", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "addInputWall", + "javaName" : "addInputWall", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "addInputCpu", + "javaName" : "addInputCpu", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rawInputDataSize", + "javaName" : "rawInputDataSize", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "inputDataSize", + "javaName" : "inputDataSize", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "inputPositions", + "javaName" : "inputPositions", + "creatorIndex" : 15, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "sumSquaredInputPositions", + "javaName" : "sumSquaredInputPositions", + "creatorIndex" : 16, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "getOutputCalls", + "javaName" : "getOutputCalls", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "getOutputWall", + "javaName" : "getOutputWall", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "getOutputCpu", + "javaName" : "getOutputCpu", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 21, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "dynamicFilterSplitsProcessed", + "javaName" : "dynamicFilterSplitsProcessed", + "creatorIndex" : 22, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "blockedWall", + "javaName" : "blockedWall", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "finishCalls", + "javaName" : "finishCalls", + "creatorIndex" : 25, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "finishWall", + "javaName" : "finishWall", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "finishCpu", + "javaName" : "finishCpu", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 29, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "systemMemoryReservation", + "javaName" : "systemMemoryReservation", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 31, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakSystemMemoryReservation", + "javaName" : "peakSystemMemoryReservation", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakRevocableMemoryReservation", + "javaName" : "peakRevocableMemoryReservation", + "creatorIndex" : 33, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTotalMemoryReservation", + "javaName" : "peakTotalMemoryReservation", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "spilledDataSize", + "javaName" : "spilledDataSize", + "creatorIndex" : 35, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "blockedReason", + "javaName" : "blockedReason", + "creatorIndex" : 36, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "info", + "javaName" : "info", + "creatorIndex" : 37, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "io.trino.operator.OperatorInfo" + } + } ] + }, { + "javaName" : "io.trino.operator.PageBufferClientStatus", + "simpleName" : "PageBufferClientStatus", + "kind" : "class", + "properties" : [ { + "jsonName" : "uri", + "javaName" : "uri", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "lastUpdate", + "javaName" : "lastUpdate", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "rowsReceived", + "javaName" : "rowsReceived", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "pagesReceived", + "javaName" : "pagesReceived", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "rowsRejected", + "javaName" : "rowsRejected", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Long" + } + } + }, { + "jsonName" : "pagesRejected", + "javaName" : "pagesRejected", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "requestsScheduled", + "javaName" : "requestsScheduled", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "requestsCompleted", + "javaName" : "requestsCompleted", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "requestsFailed", + "javaName" : "requestsFailed", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "httpRequestState", + "javaName" : "httpRequestState", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.operator.PartitionedOutputOperator$PartitionedOutputInfo", + "simpleName" : "PartitionedOutputInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "rowsAdded", + "javaName" : "rowsAdded", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "pagesAdded", + "javaName" : "pagesAdded", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputBufferPeakMemoryUsage", + "javaName" : "outputBufferPeakMemoryUsage", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + } ] + }, { + "javaName" : "io.trino.operator.PipelineStats", + "simpleName" : "PipelineStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "pipelineId", + "javaName" : "pipelineId", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "firstStartTime", + "javaName" : "firstStartTime", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "lastStartTime", + "javaName" : "lastStartTime", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "lastEndTime", + "javaName" : "lastEndTime", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "inputPipeline", + "javaName" : "inputPipeline", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "outputPipeline", + "javaName" : "outputPipeline", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedPartitionedDrivers", + "javaName" : "queuedPartitionedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningPartitionedDrivers", + "javaName" : "runningPartitionedDrivers", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "systemMemoryReservation", + "javaName" : "systemMemoryReservation", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.airlift.stats.Distribution$DistributionSnapshot" + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.airlift.stats.Distribution$DistributionSnapshot" + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 21, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 24, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 27, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rawInputDataSize", + "javaName" : "rawInputDataSize", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "rawInputPositions", + "javaName" : "rawInputPositions", + "creatorIndex" : 29, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 31, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 33, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "operatorSummaries", + "javaName" : "operatorSummaries", + "creatorIndex" : 35, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.OperatorStats" + } + } + }, { + "jsonName" : "drivers", + "javaName" : "drivers", + "creatorIndex" : 36, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.DriverStats" + } + } + } ] + }, { + "javaName" : "io.trino.operator.SplitOperatorInfo", + "simpleName" : "SplitOperatorInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "splitInfo", + "javaName" : "splitInfo", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } ] + }, { + "javaName" : "io.trino.operator.StageExecutionDescriptor", + "simpleName" : "StageExecutionDescriptor", + "kind" : "class", + "properties" : [ { + "jsonName" : "strategy", + "javaName" : "stageExecutionStrategy", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.operator.StageExecutionDescriptor$StageExecutionStrategy", + "enumValues" : [ "UNGROUPED_EXECUTION", "FIXED_LIFESPAN_SCHEDULE_GROUPED_EXECUTION", "DYNAMIC_LIFESPAN_SCHEDULE_GROUPED_EXECUTION" ] + } + }, { + "jsonName" : "groupedExecutionScanNodes", + "javaName" : "jsonSerializableGroupedExecutionScanNodes", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.operator.TableFinishInfo", + "simpleName" : "TableFinishInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "connectorOutputMetadata", + "javaName" : "connectorOutputMetadata", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "com.fasterxml.jackson.databind.JsonNode" + } + }, { + "jsonName" : "jsonLengthLimitExceeded", + "javaName" : "jsonLengthLimitExceeded", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "statisticsWallTime", + "javaName" : "statisticsWallTime", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "statisticsCpuTime", + "javaName" : "statisticsCpuTime", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.operator.TableWriterOperator$TableWriterInfo", + "simpleName" : "TableWriterInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "pageSinkPeakMemoryUsage", + "javaName" : "pageSinkPeakMemoryUsage", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "statisticsWallTime", + "javaName" : "statisticsWallTime", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "statisticsCpuTime", + "javaName" : "statisticsCpuTime", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "validationCpuTime", + "javaName" : "validationCpuTime", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.operator.TaskStats", + "simpleName" : "TaskStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "createTime", + "javaName" : "createTime", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "firstStartTime", + "javaName" : "firstStartTime", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "lastStartTime", + "javaName" : "lastStartTime", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "lastEndTime", + "javaName" : "lastEndTime", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "endTime", + "javaName" : "endTime", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedPartitionedDrivers", + "javaName" : "queuedPartitionedDrivers", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningPartitionedDrivers", + "javaName" : "runningPartitionedDrivers", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 13, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cumulativeUserMemory", + "javaName" : "cumulativeUserMemory", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "systemMemoryReservation", + "javaName" : "systemMemoryReservation", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 21, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 24, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 27, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rawInputDataSize", + "javaName" : "rawInputDataSize", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "rawInputPositions", + "javaName" : "rawInputPositions", + "creatorIndex" : 29, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 31, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 33, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullGcCount", + "javaName" : "fullGcCount", + "creatorIndex" : 35, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "fullGcTime", + "javaName" : "fullGcTime", + "creatorIndex" : 36, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "pipelines", + "javaName" : "pipelines", + "creatorIndex" : 37, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.PipelineStats" + } + } + } ] + }, { + "javaName" : "io.trino.operator.WindowInfo", + "simpleName" : "WindowInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "windowInfos", + "javaName" : "windowInfos", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.WindowInfo$DriverWindowInfo" + } + } + } ] + }, { + "javaName" : "io.trino.operator.WindowInfo$DriverWindowInfo", + "simpleName" : "DriverWindowInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "sumSquaredDifferencesPositionsOfIndex", + "javaName" : "sumSquaredDifferencesPositionsOfIndex", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "sumSquaredDifferencesSizeOfIndex", + "javaName" : "sumSquaredDifferencesSizeOfIndex", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "sumSquaredDifferencesSizeInPartition", + "javaName" : "sumSquaredDifferencesSizeInPartition", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "totalPartitionsCount", + "javaName" : "totalPartitionsCount", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalRowsCount", + "javaName" : "totalRowsCount", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "numberOfIndexes", + "javaName" : "numberOfIndexes", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + } ] + }, { + "javaName" : "io.trino.operator.exchange.LocalExchangeBufferInfo", + "simpleName" : "LocalExchangeBufferInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "bufferedBytes", + "javaName" : "bufferedBytes", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "bufferedPages", + "javaName" : "bufferedPages", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.server.BasicQueryInfo", + "simpleName" : "BasicQueryInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "queryId", + "javaName" : "queryId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.QueryId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "session", + "javaName" : "session", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.SessionRepresentation" + } + }, { + "jsonName" : "resourceGroupId", + "javaName" : "resourceGroupId", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.resourcegroups.ResourceGroupId", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.QueryState", + "enumValues" : [ "QUEUED", "WAITING_FOR_RESOURCES", "DISPATCHING", "PLANNING", "STARTING", "RUNNING", "FINISHING", "FINISHED", "FAILED" ] + } + }, { + "jsonName" : "memoryPool", + "javaName" : "memoryPool", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.memory.MemoryPoolId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "scheduled", + "javaName" : "scheduled", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "self", + "javaName" : "self", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "query", + "javaName" : "query", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "updateType", + "javaName" : "updateType", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "preparedQuery", + "javaName" : "preparedQuery", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queryStats", + "javaName" : "queryStats", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.server.BasicQueryStats" + } + }, { + "jsonName" : "errorType", + "javaName" : "errorType", + "creatorIndex" : 11, + "nullability" : "nullable", + "type" : { + "kind" : "enum", + "name" : "io.trino.spi.ErrorType", + "enumValues" : [ "USER_ERROR", "INTERNAL_ERROR", "INSUFFICIENT_RESOURCES", "EXTERNAL" ] + } + }, { + "jsonName" : "errorCode", + "javaName" : "errorCode", + "creatorIndex" : 12, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.ErrorCode" + } + }, { + "jsonName" : "queryType", + "javaName" : "queryType", + "creatorIndex" : 13, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.spi.resourcegroups.QueryType", + "enumValues" : [ "DATA_DEFINITION", "DELETE", "DESCRIBE", "EXPLAIN", "ANALYZE", "INSERT", "SELECT" ] + } + } + } ] + }, { + "javaName" : "io.trino.server.BasicQueryStats", + "simpleName" : "BasicQueryStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "createTime", + "javaName" : "createTime", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "endTime", + "javaName" : "endTime", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "org.joda.time.DateTime" + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "executionTime", + "javaName" : "executionTime", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "rawInputDataSize", + "javaName" : "rawInputDataSize", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "rawInputPositions", + "javaName" : "rawInputPositions", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "cumulativeUserMemory", + "javaName" : "cumulativeUserMemory", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalMemoryReservation", + "javaName" : "totalMemoryReservation", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTotalMemoryReservation", + "javaName" : "peakTotalMemoryReservation", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 19, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "progressPercentage", + "javaName" : "progressPercentage", + "creatorIndex" : 21, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Double" + } + } + } ] + }, { + "javaName" : "io.trino.server.DynamicFilterService$DynamicFilterDomainStats", + "simpleName" : "DynamicFilterDomainStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "dynamicFilterId", + "javaName" : "dynamicFilterId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.DynamicFilterId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "simplifiedDomain", + "javaName" : "simplifiedDomain", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "rangeCount", + "javaName" : "rangeCount", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "discreteValuesCount", + "javaName" : "discreteValuesCount", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "collectionDuration", + "javaName" : "collectionDuration", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.server.DynamicFilterService$DynamicFiltersStats", + "simpleName" : "DynamicFiltersStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "dynamicFilterDomainStats", + "javaName" : "dynamicFilterDomainStats", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.server.DynamicFilterService$DynamicFilterDomainStats" + } + } + }, { + "jsonName" : "lazyDynamicFilters", + "javaName" : "lazyDynamicFilters", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "replicatedDynamicFilters", + "javaName" : "replicatedDynamicFilters", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalDynamicFilters", + "javaName" : "totalDynamicFilters", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "dynamicFiltersCompleted", + "javaName" : "dynamicFiltersCompleted", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.spi.ErrorCode", + "simpleName" : "ErrorCode", + "kind" : "class", + "properties" : [ { + "jsonName" : "code", + "javaName" : "code", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.spi.ErrorType", + "enumValues" : [ "USER_ERROR", "INTERNAL_ERROR", "INSUFFICIENT_RESOURCES", "EXTERNAL" ] + } + } ] + }, { + "javaName" : "io.trino.spi.TrinoWarning", + "simpleName" : "TrinoWarning", + "kind" : "class", + "properties" : [ { + "jsonName" : "warningCode", + "javaName" : "warningCode", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.WarningCode" + } + }, { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.WarningCode", + "simpleName" : "WarningCode", + "kind" : "class", + "properties" : [ { + "jsonName" : "code", + "javaName" : "code", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.connector.SchemaTableName", + "simpleName" : "SchemaTableName", + "kind" : "class", + "properties" : [ { + "jsonName" : "schema", + "javaName" : "schemaName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "tableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.ColumnInfo", + "simpleName" : "ColumnInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "column", + "javaName" : "column", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "masks", + "javaName" : "masks", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.RoutineInfo", + "simpleName" : "RoutineInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "routine", + "javaName" : "routine", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "authorization", + "javaName" : "authorization", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.StageGcStatistics", + "simpleName" : "StageGcStatistics", + "kind" : "class", + "properties" : [ { + "jsonName" : "stageId", + "javaName" : "stageId", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "tasks", + "javaName" : "tasks", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "fullGcTasks", + "javaName" : "fullGcTasks", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "minFullGcSec", + "javaName" : "minFullGcSec", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "maxFullGcSec", + "javaName" : "maxFullGcSec", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalFullGcSec", + "javaName" : "totalFullGcSec", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "averageFullGcSec", + "javaName" : "averageFullGcSec", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.TableInfo", + "simpleName" : "TableInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalog", + "javaName" : "catalog", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "authorization", + "javaName" : "authorization", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "filters", + "javaName" : "filters", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.ColumnInfo" + } + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.Domain", + "simpleName" : "Domain", + "kind" : "class", + "properties" : [ { + "jsonName" : "values", + "javaName" : "values", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.predicate.ValueSet" + } + }, { + "jsonName" : "nullAllowed", + "javaName" : "nullAllowed", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.NullableValue", + "simpleName" : "NullableValue", + "kind" : "class", + "properties" : [ { + "jsonName" : "serializable", + "javaName" : "serializable", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.NullableValue$Serializable" + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.NullableValue$Serializable", + "simpleName" : "Serializable", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "block", + "javaName" : "block", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.block.Block" + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.TupleDomain", + "simpleName" : "TupleDomain", + "kind" : "class", + "properties" : [ { + "jsonName" : "columnDomains", + "javaName" : "columnDomains", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.TupleDomain$ColumnDomain" + } + } + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.TupleDomain$ColumnDomain", + "simpleName" : "ColumnDomain", + "kind" : "class", + "properties" : [ { + "jsonName" : "column", + "javaName" : "column", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + }, { + "jsonName" : "domain", + "javaName" : "domain", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.Domain" + } + } ] + }, { + "javaName" : "io.trino.spi.security.SelectedRole", + "simpleName" : "SelectedRole", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.spi.security.SelectedRole$Type", + "enumValues" : [ "ROLE", "ALL", "NONE" ] + } + }, { + "jsonName" : "role", + "javaName" : "role", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.spi.session.ResourceEstimates", + "simpleName" : "ResourceEstimates", + "kind" : "class", + "properties" : [ { + "jsonName" : "executionTime", + "javaName" : "executionTime", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "java.time.Duration" + } + } + }, { + "jsonName" : "cpuTime", + "javaName" : "cpuTime", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "java.time.Duration" + } + } + }, { + "jsonName" : "peakMemoryBytes", + "javaName" : "peakMemoryBytes", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Long" + } + } + } ] + }, { + "javaName" : "io.trino.spi.statistics.ColumnStatisticMetadata", + "simpleName" : "ColumnStatisticMetadata", + "kind" : "class", + "properties" : [ { + "jsonName" : "columnName", + "javaName" : "columnName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "statisticType", + "javaName" : "statisticType", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.spi.statistics.ColumnStatisticType", + "enumValues" : [ "MIN_VALUE", "MAX_VALUE", "NUMBER_OF_DISTINCT_VALUES", "NUMBER_OF_NON_NULL_VALUES", "NUMBER_OF_TRUE_VALUES", "MAX_VALUE_SIZE_IN_BYTES", "TOTAL_SIZE_IN_BYTES" ] + } + } ] + }, { + "javaName" : "io.trino.sql.SqlPath", + "simpleName" : "SqlPath", + "kind" : "class", + "properties" : [ { + "jsonName" : "rawPath", + "javaName" : "rawPath", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.sql.analyzer.Output", + "simpleName" : "Output", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.OrderingScheme", + "simpleName" : "OrderingScheme", + "kind" : "class", + "properties" : [ { + "jsonName" : "orderBy", + "javaName" : "orderBy", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "orderings", + "javaName" : "orderings", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "enum", + "name" : "io.trino.spi.connector.SortOrder", + "enumValues" : [ "ASC_NULLS_FIRST", "ASC_NULLS_LAST", "DESC_NULLS_FIRST", "DESC_NULLS_LAST" ] + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.Partitioning", + "simpleName" : "Partitioning", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningHandle" + } + }, { + "jsonName" : "arguments", + "javaName" : "arguments", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Partitioning$ArgumentBinding" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.Partitioning$ArgumentBinding", + "simpleName" : "ArgumentBinding", + "kind" : "class", + "properties" : [ { + "jsonName" : "expression", + "javaName" : "expression", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + }, { + "jsonName" : "constant", + "javaName" : "constant", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.NullableValue" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.PartitioningHandle", + "simpleName" : "PartitioningHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "connectorId", + "javaName" : "connectorId", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorPartitioningHandle" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.PartitioningScheme", + "simpleName" : "PartitioningScheme", + "kind" : "class", + "properties" : [ { + "jsonName" : "partitioning", + "javaName" : "partitioning", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Partitioning" + } + }, { + "jsonName" : "outputLayout", + "javaName" : "outputLayout", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "hashColumn", + "javaName" : "hashColumn", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "replicateNullsAndAny", + "javaName" : "replicateNullsAndAny", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "bucketToPartition", + "javaName" : "bucketToPartition", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "array", + "elementType" : { + "kind" : "primitive", + "name" : "int" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.PlanFragment", + "simpleName" : "PlanFragment", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanFragmentId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "root", + "javaName" : "root", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "symbols", + "javaName" : "symbols", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "partitioning", + "javaName" : "partitioning", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningHandle" + } + }, { + "jsonName" : "partitionedSources", + "javaName" : "partitionedSources", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "partitioningScheme", + "javaName" : "partitioningScheme", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningScheme" + } + }, { + "jsonName" : "stageExecutionDescriptor", + "javaName" : "stageExecutionDescriptor", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.operator.StageExecutionDescriptor" + } + }, { + "jsonName" : "statsAndCosts", + "javaName" : "statsAndCosts", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.cost.StatsAndCosts" + } + }, { + "jsonName" : "jsonRepresentation", + "javaName" : "jsonRepresentation", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.AggregationNode", + "simpleName" : "AggregationNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "aggregations", + "javaName" : "aggregations", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.AggregationNode$Aggregation" + } + } + }, { + "jsonName" : "groupingSets", + "javaName" : "groupingSets", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.AggregationNode$GroupingSetDescriptor" + } + }, { + "jsonName" : "preGroupedSymbols", + "javaName" : "preGroupedSymbols", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "step", + "javaName" : "step", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.AggregationNode$Step", + "enumValues" : [ "PARTIAL", "FINAL", "INTERMEDIATE", "SINGLE" ] + } + }, { + "jsonName" : "hashSymbol", + "javaName" : "hashSymbol", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "groupIdSymbol", + "javaName" : "groupIdSymbol", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.AggregationNode$Aggregation", + "simpleName" : "Aggregation", + "kind" : "class", + "properties" : [ { + "jsonName" : "resolvedFunction", + "javaName" : "resolvedFunction", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.ResolvedFunction" + } + }, { + "jsonName" : "arguments", + "javaName" : "arguments", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } + }, { + "jsonName" : "distinct", + "javaName" : "distinct", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + }, { + "jsonName" : "mask", + "javaName" : "mask", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.AggregationNode$GroupingSetDescriptor", + "simpleName" : "GroupingSetDescriptor", + "kind" : "class", + "properties" : [ { + "jsonName" : "groupingKeys", + "javaName" : "groupingKeys", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "groupingSetCount", + "javaName" : "groupingSetCount", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "globalGroupingSets", + "javaName" : "globalGroupingSets", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ApplyNode", + "simpleName" : "ApplyNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "input", + "javaName" : "input", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "subquery", + "javaName" : "subquery", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "subqueryAssignments", + "javaName" : "subqueryAssignments", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.Assignments" + } + }, { + "jsonName" : "correlation", + "javaName" : "correlation", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "originSubquery", + "javaName" : "originSubquery", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Node" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.AssignUniqueId", + "simpleName" : "AssignUniqueId", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "idColumn", + "javaName" : "idColumn", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.Assignments", + "simpleName" : "Assignments", + "kind" : "class", + "properties" : [ { + "jsonName" : "assignments", + "javaName" : "assignments", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.CorrelatedJoinNode", + "simpleName" : "CorrelatedJoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "input", + "javaName" : "input", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "subquery", + "javaName" : "subquery", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "correlation", + "javaName" : "correlation", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.CorrelatedJoinNode$Type", + "enumValues" : [ "INNER", "LEFT", "RIGHT", "FULL" ] + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + }, { + "jsonName" : "originSubquery", + "javaName" : "originSubquery", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Node" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.DeleteNode", + "simpleName" : "DeleteNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "target", + "javaName" : "target", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.TableWriterNode$DeleteTarget" + } + }, { + "jsonName" : "rowId", + "javaName" : "rowId", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.DistinctLimitNode", + "simpleName" : "DistinctLimitNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "limit", + "javaName" : "limit", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "partial", + "javaName" : "partial", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "distinctSymbols", + "javaName" : "distinctSymbols", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "hashSymbol", + "javaName" : "hashSymbol", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.EnforceSingleRowNode", + "simpleName" : "EnforceSingleRowNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ExchangeNode", + "simpleName" : "ExchangeNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.ExchangeNode$Type", + "enumValues" : [ "GATHER", "REPARTITION", "REPLICATE" ] + } + }, { + "jsonName" : "scope", + "javaName" : "scope", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.ExchangeNode$Scope", + "enumValues" : [ "LOCAL", "REMOTE" ] + } + }, { + "jsonName" : "partitioningScheme", + "javaName" : "partitioningScheme", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningScheme" + } + }, { + "jsonName" : "sources", + "javaName" : "sources", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + } + }, { + "jsonName" : "inputs", + "javaName" : "inputs", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ExplainAnalyzeNode", + "simpleName" : "ExplainAnalyzeNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "outputSymbol", + "javaName" : "outputSymbol", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "actualOutputs", + "javaName" : "actualOutputs", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "verbose", + "javaName" : "verbose", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.FilterNode", + "simpleName" : "FilterNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "predicate", + "javaName" : "predicate", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.GroupIdNode", + "simpleName" : "GroupIdNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "groupingSets", + "javaName" : "groupingSets", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "groupingColumns", + "javaName" : "groupingColumns", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "aggregationArguments", + "javaName" : "aggregationArguments", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "groupIdSymbol", + "javaName" : "groupIdSymbol", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.IndexJoinNode", + "simpleName" : "IndexJoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.IndexJoinNode$Type", + "enumValues" : [ "INNER", "SOURCE_OUTER" ] + } + }, { + "jsonName" : "probeSource", + "javaName" : "probeSource", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "indexSource", + "javaName" : "indexSource", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "criteria", + "javaName" : "criteria", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.IndexJoinNode$EquiJoinClause" + } + } + }, { + "jsonName" : "probeHashSymbol", + "javaName" : "probeHashSymbol", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "indexHashSymbol", + "javaName" : "indexHashSymbol", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.IndexJoinNode$EquiJoinClause", + "simpleName" : "EquiJoinClause", + "kind" : "class", + "properties" : [ { + "jsonName" : "probe", + "javaName" : "probe", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "index", + "javaName" : "index", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.IndexSourceNode", + "simpleName" : "IndexSourceNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "indexHandle", + "javaName" : "indexHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.IndexHandle" + } + }, { + "jsonName" : "tableHandle", + "javaName" : "tableHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + }, { + "jsonName" : "lookupSymbols", + "javaName" : "lookupSymbols", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "assignments", + "javaName" : "assignments", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ColumnHandle" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.IntersectNode", + "simpleName" : "IntersectNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "sources", + "javaName" : "sources", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + } + }, { + "jsonName" : "outputToInputs", + "javaName" : "outputToInputs", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "com.google.common.collect.ListMultimap" + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "distinct", + "javaName" : "distinct", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.JoinNode", + "simpleName" : "JoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.JoinNode$Type", + "enumValues" : [ "INNER", "LEFT", "RIGHT", "FULL" ] + } + }, { + "jsonName" : "left", + "javaName" : "left", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "right", + "javaName" : "right", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "criteria", + "javaName" : "criteria", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.JoinNode$EquiJoinClause" + } + } + }, { + "jsonName" : "leftOutputSymbols", + "javaName" : "leftOutputSymbols", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "rightOutputSymbols", + "javaName" : "rightOutputSymbols", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } + }, { + "jsonName" : "leftHashSymbol", + "javaName" : "leftHashSymbol", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "rightHashSymbol", + "javaName" : "rightHashSymbol", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "distributionType", + "javaName" : "distributionType", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.JoinNode$DistributionType", + "enumValues" : [ "PARTITIONED", "REPLICATED" ] + } + } + }, { + "jsonName" : "spillable", + "javaName" : "spillable", + "creatorIndex" : 11, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Boolean" + } + } + }, { + "jsonName" : "dynamicFilters", + "javaName" : "dynamicFilters", + "creatorIndex" : 12, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.DynamicFilterId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "reorderJoinStatsAndCost", + "javaName" : "reorderJoinStatsAndCost", + "creatorIndex" : 13, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.cost.PlanNodeStatsAndCostSummary" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.JoinNode$EquiJoinClause", + "simpleName" : "EquiJoinClause", + "kind" : "class", + "properties" : [ { + "jsonName" : "left", + "javaName" : "left", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "right", + "javaName" : "right", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.LimitNode", + "simpleName" : "LimitNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "count", + "javaName" : "count", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "tiesResolvingScheme", + "javaName" : "tiesResolvingScheme", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + }, { + "jsonName" : "partial", + "javaName" : "partial", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.MarkDistinctNode", + "simpleName" : "MarkDistinctNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "markerSymbol", + "javaName" : "markerSymbol", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "distinctSymbols", + "javaName" : "distinctSymbols", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "hashSymbol", + "javaName" : "hashSymbol", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.OutputNode", + "simpleName" : "OutputNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "columns", + "javaName" : "columnNames", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ProjectNode", + "simpleName" : "ProjectNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "assignments", + "javaName" : "assignments", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.Assignments" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.RemoteSourceNode", + "simpleName" : "RemoteSourceNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "sourceFragmentIds", + "javaName" : "sourceFragmentIds", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanFragmentId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + }, { + "jsonName" : "exchangeType", + "javaName" : "exchangeType", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.ExchangeNode$Type", + "enumValues" : [ "GATHER", "REPARTITION", "REPLICATE" ] + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.RowNumberNode", + "simpleName" : "RowNumberNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "partitionBy", + "javaName" : "partitionBy", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "orderSensitive", + "javaName" : "orderSensitive", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "rowNumberSymbol", + "javaName" : "rowNumberSymbol", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "maxRowCountPerPartition", + "javaName" : "maxRowCountPerPartition", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "hashSymbol", + "javaName" : "hashSymbol", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.SampleNode", + "simpleName" : "SampleNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "sampleRatio", + "javaName" : "sampleRatio", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "sampleType", + "javaName" : "sampleType", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.SampleNode$Type", + "enumValues" : [ "BERNOULLI", "SYSTEM" ] + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.SemiJoinNode", + "simpleName" : "SemiJoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "filteringSource", + "javaName" : "filteringSource", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "sourceJoinSymbol", + "javaName" : "sourceJoinSymbol", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "filteringSourceJoinSymbol", + "javaName" : "filteringSourceJoinSymbol", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "semiJoinOutput", + "javaName" : "semiJoinOutput", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "sourceHashSymbol", + "javaName" : "sourceHashSymbol", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "filteringSourceHashSymbol", + "javaName" : "filteringSourceHashSymbol", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "distributionType", + "javaName" : "distributionType", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.SemiJoinNode$DistributionType", + "enumValues" : [ "PARTITIONED", "REPLICATED" ] + } + } + }, { + "jsonName" : "dynamicFilterId", + "javaName" : "dynamicFilterId", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.DynamicFilterId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.SortNode", + "simpleName" : "SortNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + }, { + "jsonName" : "partial", + "javaName" : "partial", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.SpatialJoinNode", + "simpleName" : "SpatialJoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.SpatialJoinNode$Type", + "enumValues" : [ "INNER", "LEFT" ] + } + }, { + "jsonName" : "left", + "javaName" : "left", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "right", + "javaName" : "right", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + }, { + "jsonName" : "leftPartitionSymbol", + "javaName" : "leftPartitionSymbol", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "rightPartitionSymbol", + "javaName" : "rightPartitionSymbol", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "kdbTree", + "javaName" : "kdbTree", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticAggregations", + "simpleName" : "StatisticAggregations", + "kind" : "class", + "properties" : [ { + "jsonName" : "aggregations", + "javaName" : "aggregations", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.AggregationNode$Aggregation" + } + } + }, { + "jsonName" : "groupingSymbols", + "javaName" : "groupingSymbols", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor", + "simpleName" : "StatisticAggregationsDescriptor", + "kind" : "class", + "properties" : [ { + "jsonName" : "grouping", + "javaName" : "grouping", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + }, { + "jsonName" : "tableStatistics", + "javaName" : "tableStatistics", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "enum", + "name" : "io.trino.spi.statistics.TableStatisticType", + "enumValues" : [ "ROW_COUNT" ] + }, + "valueType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + }, { + "jsonName" : "columnStatistics", + "javaName" : "columnStatistics", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.spi.statistics.ColumnStatisticMetadata" + }, + "valueType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticsWriterNode", + "simpleName" : "StatisticsWriterNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "target", + "javaName" : "target", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.StatisticsWriterNode$WriteStatisticsTarget" + } + }, { + "jsonName" : "rowCountSymbol", + "javaName" : "rowCountSymbol", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "rowCountEnabled", + "javaName" : "rowCountEnabled", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "descriptor", + "javaName" : "descriptor", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticsWriterNode$WriteStatisticsHandle", + "simpleName" : "WriteStatisticsHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.AnalyzeTableHandle" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableFinishNode", + "simpleName" : "TableFinishNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "target", + "javaName" : "target", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.TableWriterNode$WriterTarget" + } + }, { + "jsonName" : "rowCountSymbol", + "javaName" : "rowCountSymbol", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "statisticsAggregation", + "javaName" : "statisticsAggregation", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregations" + } + } + }, { + "jsonName" : "statisticsAggregationDescriptor", + "javaName" : "statisticsAggregationDescriptor", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableScanNode", + "simpleName" : "TableScanNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "assignments", + "javaName" : "assignments", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ColumnHandle" + } + } + }, { + "jsonName" : "forDelete", + "javaName" : "forDelete", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode", + "simpleName" : "TableWriterNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "target", + "javaName" : "target", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.TableWriterNode$WriterTarget" + } + }, { + "jsonName" : "rowCountSymbol", + "javaName" : "rowCountSymbol", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fragmentSymbol", + "javaName" : "fragmentSymbol", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "columnNames", + "javaName" : "columnNames", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "notNullColumnSymbols", + "javaName" : "notNullColumnSymbols", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "partitioningScheme", + "javaName" : "partitioningScheme", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningScheme" + } + } + }, { + "jsonName" : "statisticsAggregation", + "javaName" : "statisticsAggregation", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregations" + } + } + }, { + "jsonName" : "statisticsAggregationDescriptor", + "javaName" : "statisticsAggregationDescriptor", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode$CreateTarget", + "simpleName" : "CreateTarget", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.OutputTableHandle" + } + }, { + "jsonName" : "schemaTableName", + "javaName" : "schemaTableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.SchemaTableName" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode$DeleteTarget", + "simpleName" : "DeleteTarget", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + }, { + "jsonName" : "schemaTableName", + "javaName" : "schemaTableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.SchemaTableName" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode$InsertTarget", + "simpleName" : "InsertTarget", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.InsertTableHandle" + } + }, { + "jsonName" : "schemaTableName", + "javaName" : "schemaTableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.SchemaTableName" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode$RefreshMaterializedViewTarget", + "simpleName" : "RefreshMaterializedViewTarget", + "kind" : "class", + "properties" : [ { + "jsonName" : "tableHandle", + "javaName" : "tableHandle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + }, { + "jsonName" : "insertHandle", + "javaName" : "insertHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.InsertTableHandle" + } + }, { + "jsonName" : "schemaTableName", + "javaName" : "schemaTableName", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.SchemaTableName" + } + }, { + "jsonName" : "sourceTableHandles", + "javaName" : "sourceTableHandles", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TopNNode", + "simpleName" : "TopNNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "count", + "javaName" : "count", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + }, { + "jsonName" : "step", + "javaName" : "step", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.TopNNode$Step", + "enumValues" : [ "SINGLE", "PARTIAL", "FINAL" ] + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TopNRowNumberNode", + "simpleName" : "TopNRowNumberNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "specification", + "javaName" : "specification", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.WindowNode$Specification" + } + }, { + "jsonName" : "rowNumberSymbol", + "javaName" : "rowNumberSymbol", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "maxRowCountPerPartition", + "javaName" : "maxRowCountPerPartition", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "partial", + "javaName" : "partial", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "hashSymbol", + "javaName" : "hashSymbol", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.UnionNode", + "simpleName" : "UnionNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "sources", + "javaName" : "sources", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + } + }, { + "jsonName" : "outputToInputs", + "javaName" : "outputToInputs", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "com.google.common.collect.ListMultimap" + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.UnnestNode", + "simpleName" : "UnnestNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "replicateSymbols", + "javaName" : "replicateSymbols", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "mappings", + "javaName" : "mappings", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.UnnestNode$Mapping" + } + } + }, { + "jsonName" : "ordinalitySymbol", + "javaName" : "ordinalitySymbol", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "joinType", + "javaName" : "joinType", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.JoinNode$Type", + "enumValues" : [ "INNER", "LEFT", "RIGHT", "FULL" ] + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.UnnestNode$Mapping", + "simpleName" : "Mapping", + "kind" : "class", + "properties" : [ { + "jsonName" : "input", + "javaName" : "input", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ValuesNode", + "simpleName" : "ValuesNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "rowCount", + "javaName" : "rowCount", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "rows", + "javaName" : "rows", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.WindowNode", + "simpleName" : "WindowNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "specification", + "javaName" : "specification", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.WindowNode$Specification" + } + }, { + "jsonName" : "windowFunctions", + "javaName" : "windowFunctions", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.WindowNode$Function" + } + } + }, { + "jsonName" : "hashSymbol", + "javaName" : "hashSymbol", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "prePartitionedInputs", + "javaName" : "prePartitionedInputs", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "preSortedOrderPrefix", + "javaName" : "preSortedOrderPrefix", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.WindowNode$Frame", + "simpleName" : "Frame", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.tree.WindowFrame$Type", + "enumValues" : [ "RANGE", "ROWS", "GROUPS" ] + } + }, { + "jsonName" : "startType", + "javaName" : "startType", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.tree.FrameBound$Type", + "enumValues" : [ "UNBOUNDED_PRECEDING", "PRECEDING", "CURRENT_ROW", "FOLLOWING", "UNBOUNDED_FOLLOWING" ] + } + }, { + "jsonName" : "startValue", + "javaName" : "startValue", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "sortKeyCoercedForFrameStartComparison", + "javaName" : "sortKeyCoercedForFrameStartComparison", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "endType", + "javaName" : "endType", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.tree.FrameBound$Type", + "enumValues" : [ "UNBOUNDED_PRECEDING", "PRECEDING", "CURRENT_ROW", "FOLLOWING", "UNBOUNDED_FOLLOWING" ] + } + }, { + "jsonName" : "endValue", + "javaName" : "endValue", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "sortKeyCoercedForFrameEndComparison", + "javaName" : "sortKeyCoercedForFrameEndComparison", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "originalStartValue", + "javaName" : "originalStartValue", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } + }, { + "jsonName" : "originalEndValue", + "javaName" : "originalEndValue", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.WindowNode$Function", + "simpleName" : "Function", + "kind" : "class", + "properties" : [ { + "jsonName" : "resolvedFunction", + "javaName" : "resolvedFunction", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.ResolvedFunction" + } + }, { + "jsonName" : "arguments", + "javaName" : "arguments", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Expression" + } + } + }, { + "jsonName" : "frame", + "javaName" : "frame", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.WindowNode$Frame" + } + }, { + "jsonName" : "ignoreNulls", + "javaName" : "ignoreNulls", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.WindowNode$Specification", + "simpleName" : "Specification", + "kind" : "class", + "properties" : [ { + "jsonName" : "partitionBy", + "javaName" : "partitionBy", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.Symbol", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + } ] + } ] +} \ No newline at end of file diff --git a/modelgen/schemas/483.json b/modelgen/schemas/483.json new file mode 100644 index 00000000..4d21d1c2 --- /dev/null +++ b/modelgen/schemas/483.json @@ -0,0 +1,12233 @@ +{ + "schemaVersion" : 1, + "trinoVersion" : "483", + "roots" : [ "io.trino.client.QueryResults", "io.trino.execution.QueryInfo", "io.trino.server.BasicQueryInfo", "io.trino.sql.planner.plan.OutputNode", "io.trino.sql.planner.plan.ProjectNode", "io.trino.sql.planner.plan.TableScanNode", "io.trino.sql.planner.plan.ValuesNode", "io.trino.sql.planner.plan.AggregationNode", "io.trino.sql.planner.plan.MarkDistinctNode", "io.trino.sql.planner.plan.FilterNode", "io.trino.sql.planner.plan.WindowNode", "io.trino.sql.planner.plan.RowNumberNode", "io.trino.sql.planner.plan.LimitNode", "io.trino.sql.planner.plan.DistinctLimitNode", "io.trino.sql.planner.plan.TopNNode", "io.trino.sql.planner.plan.SampleNode", "io.trino.sql.planner.plan.SortNode", "io.trino.sql.planner.plan.RemoteSourceNode", "io.trino.sql.planner.plan.JoinNode", "io.trino.sql.planner.plan.SemiJoinNode", "io.trino.sql.planner.plan.SpatialJoinNode", "io.trino.sql.planner.plan.IndexJoinNode", "io.trino.sql.planner.plan.IndexSourceNode", "io.trino.sql.planner.plan.TableWriterNode", "io.trino.sql.planner.plan.TableFinishNode", "io.trino.sql.planner.plan.UnnestNode", "io.trino.sql.planner.plan.ExchangeNode", "io.trino.sql.planner.plan.UnionNode", "io.trino.sql.planner.plan.IntersectNode", "io.trino.sql.planner.plan.EnforceSingleRowNode", "io.trino.sql.planner.plan.GroupIdNode", "io.trino.sql.planner.plan.ExplainAnalyzeNode", "io.trino.sql.planner.plan.ApplyNode", "io.trino.sql.planner.plan.AssignUniqueId", "io.trino.sql.planner.plan.CorrelatedJoinNode", "io.trino.sql.planner.plan.StatisticsWriterNode", "io.trino.metadata.AnalyzeTableHandle", "io.trino.metadata.InsertTableHandle", "io.trino.metadata.OutputTableHandle", "io.trino.operator.PageBufferClientStatus", "io.trino.operator.TableFinishInfo", "io.trino.operator.TableWriterOperator$TableWriterInfo", "io.trino.operator.WindowInfo", "io.trino.operator.WindowInfo$DriverWindowInfo", "io.trino.operator.exchange.LocalExchangeBufferInfo", "io.trino.sql.planner.plan.StatisticsWriterNode$WriteStatisticsHandle", "io.trino.sql.planner.plan.TableWriterNode$CreateTarget", "io.trino.sql.planner.plan.TableWriterNode$InsertTarget", "io.trino.sql.planner.plan.TableWriterNode$RefreshMaterializedViewTarget" ], + "models" : [ { + "javaName" : "io.trino.SessionRepresentation", + "simpleName" : "SessionRepresentation", + "kind" : "class", + "properties" : [ { + "jsonName" : "queryId", + "javaName" : "queryId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "querySpan", + "javaName" : "querySpan", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.opentelemetry.api.trace.Span" + } + }, { + "jsonName" : "transactionId", + "javaName" : "transactionId", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.transaction.TransactionId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "clientTransactionSupport", + "javaName" : "clientTransactionSupport", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "user", + "javaName" : "user", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "originalUser", + "javaName" : "originalUser", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "setOriginalRoles", + "javaName" : "originalRoles", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "groups", + "javaName" : "groups", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "originalUserGroups", + "javaName" : "originalUserGroups", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "principal", + "javaName" : "principal", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "enabledRoles", + "javaName" : "enabledRoles", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 11, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "catalog", + "javaName" : "catalog", + "creatorIndex" : 12, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 13, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "path", + "javaName" : "path", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.SqlPath" + } + }, { + "jsonName" : "traceToken", + "javaName" : "traceToken", + "creatorIndex" : 15, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "timeZoneKey", + "javaName" : "timeZoneKey", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.TimeZoneKey", + "elementType" : { + "kind" : "primitive", + "name" : "short" + } + } + }, { + "jsonName" : "locale", + "javaName" : "locale", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.util.Locale" + } + }, { + "jsonName" : "remoteUserAddress", + "javaName" : "remoteUserAddress", + "creatorIndex" : 18, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "userAgent", + "javaName" : "userAgent", + "creatorIndex" : 19, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "clientInfo", + "javaName" : "clientInfo", + "creatorIndex" : 20, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "clientTags", + "javaName" : "clientTags", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "clientCapabilities", + "javaName" : "clientCapabilities", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "resourceEstimates", + "javaName" : "resourceEstimates", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.session.ResourceEstimates" + } + }, { + "jsonName" : "start", + "javaName" : "start", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "systemProperties", + "javaName" : "systemProperties", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "catalogProperties", + "javaName" : "catalogProperties", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "catalogRoles", + "javaName" : "catalogRoles", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.spi.security.SelectedRole" + } + } + }, { + "jsonName" : "preparedStatements", + "javaName" : "preparedStatements", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "protocolName", + "javaName" : "protocolName", + "creatorIndex" : 29, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "queryDataEncoding", + "javaName" : "queryDataEncoding", + "creatorIndex" : 30, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.client.ClientTypeSignature", + "simpleName" : "ClientTypeSignature", + "kind" : "class", + "properties" : [ { + "jsonName" : "rawType", + "javaName" : "rawType", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "arguments", + "javaName" : "arguments", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.ClientTypeSignatureParameter" + } + } + } ] + }, { + "javaName" : "io.trino.client.ClientTypeSignatureParameter", + "simpleName" : "ClientTypeSignatureParameter", + "kind" : "class", + "properties" : [ { + "jsonName" : "kind", + "javaName" : "kind", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.client.ClientTypeSignatureParameter$ParameterKind", + "enumValues" : [ "TYPE", "NAMED_TYPE", "LONG", "VARIABLE" ] + } + }, { + "jsonName" : "value", + "javaName" : "value", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } ] + }, { + "javaName" : "io.trino.client.Column", + "simpleName" : "Column", + "kind" : "class", + "properties" : [ { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "typeSignature", + "javaName" : "typeSignature", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ClientTypeSignature" + } + } ] + }, { + "javaName" : "io.trino.client.ErrorInfo", + "simpleName" : "ErrorInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "code", + "javaName" : "code", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.client.ErrorLocation", + "simpleName" : "ErrorLocation", + "kind" : "class", + "properties" : [ { + "jsonName" : "lineNumber", + "javaName" : "lineNumber", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "columnNumber", + "javaName" : "columnNumber", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.client.FailureInfo", + "simpleName" : "FailureInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "cause", + "javaName" : "cause", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.FailureInfo" + } + }, { + "jsonName" : "suppressed", + "javaName" : "suppressed", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.FailureInfo" + } + } + }, { + "jsonName" : "stack", + "javaName" : "stack", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "errorInfo", + "javaName" : "errorInfo", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ErrorInfo" + } + }, { + "jsonName" : "errorLocation", + "javaName" : "errorLocation", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ErrorLocation" + } + } ] + }, { + "javaName" : "io.trino.client.QueryError", + "simpleName" : "QueryError", + "kind" : "class", + "properties" : [ { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "sqlState", + "javaName" : "sqlState", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "errorCode", + "javaName" : "errorCode", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "errorName", + "javaName" : "errorName", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "errorType", + "javaName" : "errorType", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "errorLocation", + "javaName" : "errorLocation", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ErrorLocation" + } + }, { + "jsonName" : "failureInfo", + "javaName" : "failureInfo", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.FailureInfo" + } + } ] + }, { + "javaName" : "io.trino.client.QueryResults", + "simpleName" : "QueryResults", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "infoUri", + "javaName" : "infoUri", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "partialCancelUri", + "javaName" : "partialCancelUri", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "nextUri", + "javaName" : "nextUri", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.Column" + } + } + }, { + "jsonName" : "data", + "javaName" : "data", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.client.QueryData" + } + }, { + "jsonName" : "stats", + "javaName" : "stats", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.client.StatementStats" + } + }, { + "jsonName" : "error", + "javaName" : "error", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.QueryError" + } + }, { + "jsonName" : "warnings", + "javaName" : "warnings", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.Warning" + } + } + }, { + "jsonName" : "updateType", + "javaName" : "updateType", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "updateCount", + "javaName" : "updateCount", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Long" + } + } + } ] + }, { + "javaName" : "io.trino.client.StageStats", + "simpleName" : "StageStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "stageId", + "javaName" : "stageId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "done", + "javaName" : "done", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "nodes", + "javaName" : "nodes", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalSplits", + "javaName" : "totalSplits", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedSplits", + "javaName" : "queuedSplits", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningSplits", + "javaName" : "runningSplits", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedSplits", + "javaName" : "completedSplits", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cpuTimeMillis", + "javaName" : "cpuTimeMillis", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "wallTimeMillis", + "javaName" : "wallTimeMillis", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedRows", + "javaName" : "processedRows", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedBytes", + "javaName" : "processedBytes", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputBytes", + "javaName" : "physicalInputBytes", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedTasks", + "javaName" : "failedTasks", + "creatorIndex" : 13, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "coordinatorOnly", + "javaName" : "coordinatorOnly", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "subStages", + "javaName" : "subStages", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.client.StageStats" + } + } + } ] + }, { + "javaName" : "io.trino.client.StatementStats", + "simpleName" : "StatementStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "queued", + "javaName" : "queued", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "scheduled", + "javaName" : "scheduled", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "progressPercentage", + "javaName" : "progressPercentage", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Double" + } + } + }, { + "jsonName" : "runningPercentage", + "javaName" : "runningPercentage", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Double" + } + } + }, { + "jsonName" : "nodes", + "javaName" : "nodes", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalSplits", + "javaName" : "totalSplits", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedSplits", + "javaName" : "queuedSplits", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningSplits", + "javaName" : "runningSplits", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedSplits", + "javaName" : "completedSplits", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "planningTimeMillis", + "javaName" : "planningTimeMillis", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "analysisTimeMillis", + "javaName" : "analysisTimeMillis", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "cpuTimeMillis", + "javaName" : "cpuTimeMillis", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "wallTimeMillis", + "javaName" : "wallTimeMillis", + "creatorIndex" : 13, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "queuedTimeMillis", + "javaName" : "queuedTimeMillis", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "elapsedTimeMillis", + "javaName" : "elapsedTimeMillis", + "creatorIndex" : 15, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "finishingTimeMillis", + "javaName" : "finishingTimeMillis", + "creatorIndex" : 16, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputTimeMillis", + "javaName" : "physicalInputTimeMillis", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedRows", + "javaName" : "processedRows", + "creatorIndex" : 18, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedBytes", + "javaName" : "processedBytes", + "creatorIndex" : 19, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputBytes", + "javaName" : "physicalInputBytes", + "creatorIndex" : 20, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalWrittenBytes", + "javaName" : "physicalWrittenBytes", + "creatorIndex" : 21, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "internalNetworkInputBytes", + "javaName" : "internalNetworkInputBytes", + "creatorIndex" : 22, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "peakMemoryBytes", + "javaName" : "peakMemoryBytes", + "creatorIndex" : 23, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "spilledBytes", + "javaName" : "spilledBytes", + "creatorIndex" : 24, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rootStage", + "javaName" : "rootStage", + "creatorIndex" : 25, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.StageStats" + } + } ] + }, { + "javaName" : "io.trino.client.Warning", + "simpleName" : "Warning", + "kind" : "class", + "properties" : [ { + "jsonName" : "warningCode", + "javaName" : "warningCode", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.client.Warning$Code" + } + }, { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.client.Warning$Code", + "simpleName" : "Code", + "kind" : "class", + "properties" : [ { + "jsonName" : "code", + "javaName" : "code", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.cost.LocalCostEstimate", + "simpleName" : "LocalCostEstimate", + "kind" : "class", + "properties" : [ { + "jsonName" : "cpuCost", + "javaName" : "cpuCost", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "maxMemory", + "javaName" : "maxMemory", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "networkCost", + "javaName" : "networkCost", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + } ] + }, { + "javaName" : "io.trino.cost.PlanCostEstimate", + "simpleName" : "PlanCostEstimate", + "kind" : "class", + "properties" : [ { + "jsonName" : "cpuCost", + "javaName" : "cpuCost", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "maxMemory", + "javaName" : "maxMemory", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "maxMemoryWhenOutputting", + "javaName" : "maxMemoryWhenOutputting", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "networkCost", + "javaName" : "networkCost", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "rootNodeLocalCostEstimate", + "javaName" : "rootNodeLocalCostEstimate", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.cost.LocalCostEstimate" + } + } ] + }, { + "javaName" : "io.trino.cost.PlanNodeStatsAndCostSummary", + "simpleName" : "PlanNodeStatsAndCostSummary", + "kind" : "class", + "properties" : [ { + "jsonName" : "outputRowCount", + "javaName" : "outputRowCount", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "outputSizeInBytes", + "javaName" : "outputSizeInBytes", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "cpuCost", + "javaName" : "cpuCost", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "memoryCost", + "javaName" : "memoryCost", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "networkCost", + "javaName" : "networkCost", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + } ] + }, { + "javaName" : "io.trino.cost.PlanNodeStatsEstimate", + "simpleName" : "PlanNodeStatsEstimate", + "kind" : "class", + "properties" : [ { + "jsonName" : "outputRowCount", + "javaName" : "outputRowCount", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "symbolStatistics", + "javaName" : "symbolStatistics", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.cost.SymbolStatsEstimate" + } + } + } ] + }, { + "javaName" : "io.trino.cost.StatsAndCosts", + "simpleName" : "StatsAndCosts", + "kind" : "class", + "properties" : [ { + "jsonName" : "stats", + "javaName" : "stats", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.cost.PlanNodeStatsEstimate" + } + } + }, { + "jsonName" : "costs", + "javaName" : "costs", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.cost.PlanCostEstimate" + } + } + } ] + }, { + "javaName" : "io.trino.cost.SymbolStatsEstimate", + "simpleName" : "SymbolStatsEstimate", + "kind" : "class", + "properties" : [ { + "jsonName" : "lowValue", + "javaName" : "lowValue", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "highValue", + "javaName" : "highValue", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "nullsFraction", + "javaName" : "nullsFraction", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "averageRowSize", + "javaName" : "averageRowSize", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "distinctValuesCount", + "javaName" : "distinctValuesCount", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + } ] + }, { + "javaName" : "io.trino.execution.Column", + "simpleName" : "Column", + "kind" : "record", + "properties" : [ { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.execution.ExecutionFailureInfo", + "simpleName" : "ExecutionFailureInfo", + "kind" : "record", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "cause", + "javaName" : "cause", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + }, { + "jsonName" : "suppressed", + "javaName" : "suppressed", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + } + }, { + "jsonName" : "stack", + "javaName" : "stack", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "errorLocation", + "javaName" : "errorLocation", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.client.ErrorLocation" + } + }, { + "jsonName" : "errorCode", + "javaName" : "errorCode", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.ErrorCode" + } + }, { + "jsonName" : "remoteHost", + "javaName" : "remoteHost", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.HostAddress", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.execution.Input", + "simpleName" : "Input", + "kind" : "record", + "properties" : [ { + "jsonName" : "connectorName", + "javaName" : "connectorName", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "catalogVersion", + "javaName" : "catalogVersion", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.connector.CatalogVersion", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "connectorInfo", + "javaName" : "connectorInfo", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.Column" + } + } + }, { + "jsonName" : "fragmentId", + "javaName" : "fragmentId", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanFragmentId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "planNodeId", + "javaName" : "planNodeId", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.execution.QueryInfo", + "simpleName" : "QueryInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "queryId", + "javaName" : "queryId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.QueryId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "session", + "javaName" : "session", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.SessionRepresentation" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.QueryState", + "enumValues" : [ "QUEUED", "WAITING_FOR_RESOURCES", "DISPATCHING", "PLANNING", "STARTING", "RUNNING", "FINISHING", "FINISHED", "FAILED" ] + } + }, { + "jsonName" : "self", + "javaName" : "self", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "fieldNames", + "javaName" : "fieldNames", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "query", + "javaName" : "query", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "preparedQuery", + "javaName" : "preparedQuery", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queryStats", + "javaName" : "queryStats", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.QueryStats" + } + }, { + "jsonName" : "setCatalog", + "javaName" : "setCatalog", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "setSchema", + "javaName" : "setSchema", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "setPath", + "javaName" : "setPath", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "setAuthorizationUser", + "javaName" : "setAuthorizationUser", + "creatorIndex" : 11, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "resetAuthorizationUser", + "javaName" : "resetAuthorizationUser", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "setOriginalRoles", + "javaName" : "setOriginalRoles", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.security.SelectedRole" + } + } + }, { + "jsonName" : "setSessionProperties", + "javaName" : "setSessionProperties", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "resetSessionProperties", + "javaName" : "resetSessionProperties", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "setRoles", + "javaName" : "setRoles", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.spi.security.SelectedRole" + } + } + }, { + "jsonName" : "addedPreparedStatements", + "javaName" : "addedPreparedStatements", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "deallocatedPreparedStatements", + "javaName" : "deallocatedPreparedStatements", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "startedTransactionId", + "javaName" : "startedTransactionId", + "creatorIndex" : 19, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.transaction.TransactionId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "clearTransactionId", + "javaName" : "clearTransactionId", + "creatorIndex" : 20, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "updateType", + "javaName" : "updateType", + "creatorIndex" : 21, + "nullability" : "nullable", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "stages", + "javaName" : "stages", + "creatorIndex" : 22, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.StagesInfo" + } + } + }, { + "jsonName" : "failureInfo", + "javaName" : "failureInfo", + "creatorIndex" : 23, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + }, { + "jsonName" : "errorCode", + "javaName" : "errorCode", + "creatorIndex" : 24, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.ErrorCode" + } + }, { + "jsonName" : "warnings", + "javaName" : "warnings", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.TrinoWarning" + } + } + }, { + "jsonName" : "inputs", + "javaName" : "inputs", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.Input" + } + } + }, { + "jsonName" : "output", + "javaName" : "output", + "creatorIndex" : 27, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.analyzer.Output" + } + } + }, { + "jsonName" : "selectColumnsLineageInfo", + "javaName" : "selectColumnsLineageInfo", + "creatorIndex" : 28, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.ColumnLineageInfo" + } + } + } + }, { + "jsonName" : "referencedTables", + "javaName" : "referencedTables", + "creatorIndex" : 29, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.TableInfo" + } + } + }, { + "jsonName" : "routines", + "javaName" : "routines", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.RoutineInfo" + } + } + }, { + "jsonName" : "finalQueryInfo", + "javaName" : "finalQueryInfo", + "creatorIndex" : 31, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "resourceGroupId", + "javaName" : "resourceGroupId", + "creatorIndex" : 32, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.resourcegroups.ResourceGroupId", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "queryType", + "javaName" : "queryType", + "creatorIndex" : 33, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.spi.resourcegroups.QueryType", + "enumValues" : [ "SELECT", "EXPLAIN", "DESCRIBE", "INSERT", "UPDATE", "DELETE", "ANALYZE", "DATA_DEFINITION", "ALTER_TABLE_EXECUTE", "MERGE" ] + } + } + }, { + "jsonName" : "retryPolicy", + "javaName" : "retryPolicy", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.operator.RetryPolicy", + "enumValues" : [ "TASK", "QUERY", "NONE" ] + } + }, { + "jsonName" : "pruned", + "javaName" : "pruned", + "creatorIndex" : 35, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "version", + "javaName" : "version", + "creatorIndex" : 36, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.NodeVersion" + } + } ] + }, { + "javaName" : "io.trino.execution.QueryStats", + "simpleName" : "QueryStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "createTime", + "javaName" : "createTime", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "executionStartTime", + "javaName" : "executionStartTime", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "lastHeartbeat", + "javaName" : "lastHeartbeat", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "endTime", + "javaName" : "endTime", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "resourceWaitingTime", + "javaName" : "resourceWaitingTime", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "dispatchingTime", + "javaName" : "dispatchingTime", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "executionTime", + "javaName" : "executionTime", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "analysisTime", + "javaName" : "analysisTime", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "planningTime", + "javaName" : "planningTime", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "planningCpuTime", + "javaName" : "planningCpuTime", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "startingTime", + "javaName" : "startingTime", + "creatorIndex" : 12, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "finishingTime", + "javaName" : "finishingTime", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalTasks", + "javaName" : "totalTasks", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningTasks", + "javaName" : "runningTasks", + "creatorIndex" : 15, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedTasks", + "javaName" : "completedTasks", + "creatorIndex" : 16, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "failedTasks", + "javaName" : "failedTasks", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 18, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 19, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 20, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 21, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 22, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cumulativeUserMemory", + "javaName" : "cumulativeUserMemory", + "creatorIndex" : 23, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "failedCumulativeUserMemory", + "javaName" : "failedCumulativeUserMemory", + "creatorIndex" : 24, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalMemoryReservation", + "javaName" : "totalMemoryReservation", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakRevocableMemoryReservation", + "javaName" : "peakRevocableMemoryReservation", + "creatorIndex" : 29, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTotalMemoryReservation", + "javaName" : "peakTotalMemoryReservation", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTaskUserMemory", + "javaName" : "peakTaskUserMemory", + "creatorIndex" : 31, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTaskRevocableMemory", + "javaName" : "peakTaskRevocableMemory", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTaskTotalMemory", + "javaName" : "peakTaskTotalMemory", + "creatorIndex" : 33, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "spilledDataSize", + "javaName" : "spilledDataSize", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "scheduled", + "javaName" : "scheduled", + "creatorIndex" : 35, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "progressPercentage", + "javaName" : "progressPercentage", + "creatorIndex" : 36, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Double" + } + } + }, { + "jsonName" : "runningPercentage", + "javaName" : "runningPercentage", + "creatorIndex" : 37, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Double" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 38, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedScheduledTime", + "javaName" : "failedScheduledTime", + "creatorIndex" : 39, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 40, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedCpuTime", + "javaName" : "failedCpuTime", + "creatorIndex" : 41, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 42, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 43, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 44, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 45, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedPhysicalInputDataSize", + "javaName" : "failedPhysicalInputDataSize", + "creatorIndex" : 46, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 47, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedPhysicalInputPositions", + "javaName" : "failedPhysicalInputPositions", + "creatorIndex" : 48, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 49, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedPhysicalInputReadTime", + "javaName" : "failedPhysicalInputReadTime", + "creatorIndex" : 50, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 51, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedInternalNetworkInputDataSize", + "javaName" : "failedInternalNetworkInputDataSize", + "creatorIndex" : 52, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 53, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedInternalNetworkInputPositions", + "javaName" : "failedInternalNetworkInputPositions", + "creatorIndex" : 54, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 55, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedProcessedInputDataSize", + "javaName" : "failedProcessedInputDataSize", + "creatorIndex" : 56, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 57, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedProcessedInputPositions", + "javaName" : "failedProcessedInputPositions", + "creatorIndex" : 58, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "inputBlockedTime", + "javaName" : "inputBlockedTime", + "creatorIndex" : 59, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedInputBlockedTime", + "javaName" : "failedInputBlockedTime", + "creatorIndex" : 60, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 61, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedOutputDataSize", + "javaName" : "failedOutputDataSize", + "creatorIndex" : 62, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 63, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedOutputPositions", + "javaName" : "failedOutputPositions", + "creatorIndex" : 64, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputBlockedTime", + "javaName" : "outputBlockedTime", + "creatorIndex" : 65, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedOutputBlockedTime", + "javaName" : "failedOutputBlockedTime", + "creatorIndex" : 66, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 67, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedPhysicalWrittenDataSize", + "javaName" : "failedPhysicalWrittenDataSize", + "creatorIndex" : 68, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "stageGcStatistics", + "javaName" : "stageGcStatistics", + "creatorIndex" : 69, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.StageGcStatistics" + } + } + }, { + "jsonName" : "dynamicFiltersStats", + "javaName" : "dynamicFiltersStats", + "creatorIndex" : 70, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.server.DynamicFilterService$DynamicFiltersStats" + } + }, { + "jsonName" : "catalogMetadataMetrics", + "javaName" : "catalogMetadataMetrics", + "creatorIndex" : 71, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "value", + "name" : "io.trino.spi.metrics.Metrics", + "elementType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.metrics.Metric" + } + } + } + } + }, { + "jsonName" : "exchangeMetrics", + "javaName" : "exchangeMetrics", + "creatorIndex" : 72, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "value", + "name" : "io.trino.spi.metrics.Metrics", + "elementType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.metrics.Metric" + } + } + } + } + }, { + "jsonName" : "operatorSummaries", + "javaName" : "operatorSummaries", + "creatorIndex" : 73, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.OperatorStats" + } + } + }, { + "jsonName" : "optimizerRulesSummaries", + "javaName" : "optimizerRulesSummaries", + "creatorIndex" : 74, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.QueryPlanOptimizerStatistics" + } + } + } ] + }, { + "javaName" : "io.trino.execution.StageInfo", + "simpleName" : "StageInfo", + "kind" : "record", + "properties" : [ { + "jsonName" : "stageId", + "javaName" : "stageId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.execution.StageId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.StageState", + "enumValues" : [ "PLANNED", "SCHEDULING", "RUNNING", "PENDING", "FINISHED", "ABORTED", "FAILED" ] + } + }, { + "jsonName" : "plan", + "javaName" : "plan", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PlanFragment" + } + }, { + "jsonName" : "coordinatorOnly", + "javaName" : "coordinatorOnly", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "types", + "javaName" : "types", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "stageStats", + "javaName" : "stageStats", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.StageStats" + } + }, { + "jsonName" : "tasks", + "javaName" : "tasks", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.TaskInfo" + } + } + }, { + "jsonName" : "subStages", + "javaName" : "subStages", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.execution.StageId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "tables", + "javaName" : "tables", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.execution.TableInfo" + } + } + }, { + "jsonName" : "failureCause", + "javaName" : "failureCause", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + } ] + }, { + "javaName" : "io.trino.execution.StageStats", + "simpleName" : "StageStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "schedulingComplete", + "javaName" : "schedulingComplete", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "getSplitDistribution", + "javaName" : "getSplitDistribution", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.airlift.stats.Distribution$DistributionSnapshot" + } + } + }, { + "jsonName" : "splitSourceMetrics", + "javaName" : "splitSourceMetrics", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "value", + "name" : "io.trino.spi.metrics.Metrics", + "elementType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.metrics.Metric" + } + } + } + } + }, { + "jsonName" : "totalTasks", + "javaName" : "totalTasks", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningTasks", + "javaName" : "runningTasks", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedTasks", + "javaName" : "completedTasks", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "failedTasks", + "javaName" : "failedTasks", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cumulativeUserMemory", + "javaName" : "cumulativeUserMemory", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "failedCumulativeUserMemory", + "javaName" : "failedCumulativeUserMemory", + "creatorIndex" : 13, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalMemoryReservation", + "javaName" : "totalMemoryReservation", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakRevocableMemoryReservation", + "javaName" : "peakRevocableMemoryReservation", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "spilledDataSize", + "javaName" : "spilledDataSize", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedScheduledTime", + "javaName" : "failedScheduledTime", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedCpuTime", + "javaName" : "failedCpuTime", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 25, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedPhysicalInputDataSize", + "javaName" : "failedPhysicalInputDataSize", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 29, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedPhysicalInputPositions", + "javaName" : "failedPhysicalInputPositions", + "creatorIndex" : 30, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 31, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedPhysicalInputReadTime", + "javaName" : "failedPhysicalInputReadTime", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 33, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedInternalNetworkInputDataSize", + "javaName" : "failedInternalNetworkInputDataSize", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 35, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedInternalNetworkInputPositions", + "javaName" : "failedInternalNetworkInputPositions", + "creatorIndex" : 36, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 37, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedProcessedInputDataSize", + "javaName" : "failedProcessedInputDataSize", + "creatorIndex" : 38, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 39, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedProcessedInputPositions", + "javaName" : "failedProcessedInputPositions", + "creatorIndex" : 40, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "inputBlockedTime", + "javaName" : "inputBlockedTime", + "creatorIndex" : 41, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedInputBlockedTime", + "javaName" : "failedInputBlockedTime", + "creatorIndex" : 42, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "bufferedDataSize", + "javaName" : "bufferedDataSize", + "creatorIndex" : 43, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputBufferUtilization", + "javaName" : "outputBufferUtilization", + "creatorIndex" : 44, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.plugin.base.metrics.DistributionSnapshot" + } + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 45, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedOutputDataSize", + "javaName" : "failedOutputDataSize", + "creatorIndex" : 46, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 47, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failedOutputPositions", + "javaName" : "failedOutputPositions", + "creatorIndex" : 48, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputBufferMetrics", + "javaName" : "outputBufferMetrics", + "creatorIndex" : 49, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.metrics.Metrics", + "elementType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.metrics.Metric" + } + } + } + }, { + "jsonName" : "outputBlockedTime", + "javaName" : "outputBlockedTime", + "creatorIndex" : 50, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedOutputBlockedTime", + "javaName" : "failedOutputBlockedTime", + "creatorIndex" : 51, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 52, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedPhysicalWrittenDataSize", + "javaName" : "failedPhysicalWrittenDataSize", + "creatorIndex" : 53, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "gcInfo", + "javaName" : "gcInfo", + "creatorIndex" : 54, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.StageGcStatistics" + } + }, { + "jsonName" : "operatorSummaries", + "javaName" : "operatorSummaries", + "creatorIndex" : 55, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.OperatorStats" + } + } + } ] + }, { + "javaName" : "io.trino.execution.StagesInfo", + "simpleName" : "StagesInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "outputStageId", + "javaName" : "outputStageId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.execution.StageId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "stages", + "javaName" : "stages", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.StageInfo" + } + } + } ] + }, { + "javaName" : "io.trino.execution.TableInfo", + "simpleName" : "TableInfo", + "kind" : "record", + "properties" : [ { + "jsonName" : "connectorName", + "javaName" : "connectorName", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "tableName", + "javaName" : "tableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.metadata.QualifiedObjectName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "predicate", + "javaName" : "predicate", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.TupleDomain" + } + } ] + }, { + "javaName" : "io.trino.execution.TaskInfo", + "simpleName" : "TaskInfo", + "kind" : "record", + "properties" : [ { + "jsonName" : "taskStatus", + "javaName" : "taskStatus", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.TaskStatus" + } + }, { + "jsonName" : "lastHeartbeat", + "javaName" : "lastHeartbeat", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "outputBuffers", + "javaName" : "outputBuffers", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.buffer.OutputBufferInfo" + } + }, { + "jsonName" : "noMoreSplits", + "javaName" : "noMoreSplits", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "stats", + "javaName" : "stats", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.operator.TaskStats" + } + }, { + "jsonName" : "estimatedMemory", + "javaName" : "estimatedMemory", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "needsPlan", + "javaName" : "needsPlan", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.execution.TaskStatus", + "simpleName" : "TaskStatus", + "kind" : "record", + "properties" : [ { + "jsonName" : "taskId", + "javaName" : "taskId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.execution.TaskId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "taskInstanceId", + "javaName" : "taskInstanceId", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "version", + "javaName" : "version", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.TaskState", + "enumValues" : [ "PLANNED", "RUNNING", "FLUSHING", "FINISHED", "CANCELING", "CANCELED", "ABORTING", "ABORTED", "FAILING", "FAILED" ] + } + }, { + "jsonName" : "self", + "javaName" : "self", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "nodeId", + "javaName" : "nodeId", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "speculative", + "javaName" : "speculative", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "failures", + "javaName" : "failures", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.ExecutionFailureInfo" + } + } + }, { + "jsonName" : "queuedPartitionedDrivers", + "javaName" : "queuedPartitionedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningPartitionedDrivers", + "javaName" : "runningPartitionedDrivers", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "outputBufferStatus", + "javaName" : "outputBufferStatus", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.buffer.OutputBufferStatus" + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "writerInputDataSize", + "javaName" : "writerInputDataSize", + "creatorIndex" : 12, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "maxWriterCount", + "javaName" : "maxWriterCount", + "creatorIndex" : 14, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "memoryReservation", + "javaName" : "memoryReservation", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakMemoryReservation", + "javaName" : "peakMemoryReservation", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullGcCount", + "javaName" : "fullGcCount", + "creatorIndex" : 18, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "fullGcTime", + "javaName" : "fullGcTime", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "dynamicFiltersVersion", + "javaName" : "dynamicFiltersVersion", + "creatorIndex" : 20, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "queuedPartitionedSplitsWeight", + "javaName" : "queuedPartitionedSplitsWeight", + "creatorIndex" : 21, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "runningPartitionedSplitsWeight", + "javaName" : "runningPartitionedSplitsWeight", + "creatorIndex" : 22, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + } ] + }, { + "javaName" : "io.trino.execution.buffer.OutputBufferInfo", + "simpleName" : "OutputBufferInfo", + "kind" : "record", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.buffer.BufferState", + "enumValues" : [ "OPEN", "NO_MORE_BUFFERS", "NO_MORE_PAGES", "FLUSHING", "FINISHED", "ABORTED", "FAILED" ] + } + }, { + "jsonName" : "canAddBuffers", + "javaName" : "canAddBuffers", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "canAddPages", + "javaName" : "canAddPages", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "totalBufferedBytes", + "javaName" : "totalBufferedBytes", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalBufferedPages", + "javaName" : "totalBufferedPages", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalRowsSent", + "javaName" : "totalRowsSent", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalPagesSent", + "javaName" : "totalPagesSent", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "pipelinedBufferStates", + "javaName" : "pipelinedBufferStates", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.buffer.PipelinedBufferInfo" + } + } + } + }, { + "jsonName" : "utilization", + "javaName" : "utilization", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.plugin.base.metrics.TDigestHistogram" + } + } + }, { + "jsonName" : "spoolingOutputStats", + "javaName" : "spoolingOutputStats", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.execution.buffer.SpoolingOutputStats$Snapshot" + } + } + }, { + "jsonName" : "metrics", + "javaName" : "metrics", + "creatorIndex" : 11, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.metrics.Metrics", + "elementType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.metrics.Metric" + } + } + } + } + } ] + }, { + "javaName" : "io.trino.execution.buffer.OutputBufferStatus", + "simpleName" : "OutputBufferStatus", + "kind" : "record", + "properties" : [ { + "jsonName" : "outputBuffersVersion", + "javaName" : "outputBuffersVersion", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Long" + } + } + }, { + "jsonName" : "overutilized", + "javaName" : "overutilized", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "exchangeSinkInstanceHandleUpdateRequired", + "javaName" : "exchangeSinkInstanceHandleUpdateRequired", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.execution.buffer.PipelinedBufferInfo", + "simpleName" : "PipelinedBufferInfo", + "kind" : "record", + "properties" : [ { + "jsonName" : "bufferId", + "javaName" : "bufferId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.execution.buffer.PipelinedOutputBuffers$OutputBufferId", + "elementType" : { + "kind" : "primitive", + "name" : "int" + } + } + }, { + "jsonName" : "rowsAdded", + "javaName" : "rowsAdded", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "pagesAdded", + "javaName" : "pagesAdded", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "bufferedPages", + "javaName" : "bufferedPages", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "bufferedBytes", + "javaName" : "bufferedBytes", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "pagesSent", + "javaName" : "pagesSent", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "finished", + "javaName" : "finished", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.execution.buffer.SpoolingOutputStats$Snapshot", + "simpleName" : "Snapshot", + "kind" : "class", + "properties" : [ { + "jsonName" : "partitionDataSizes", + "javaName" : "partitionDataSizes", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.airlift.slice.Slice" + } + }, { + "jsonName" : "rowCount", + "javaName" : "rowCount", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + } ] + }, { + "javaName" : "io.trino.metadata.AnalyzeTableHandle", + "simpleName" : "AnalyzeTableHandle", + "kind" : "record", + "properties" : [ { + "jsonName" : "catalogHandle", + "javaName" : "catalogHandle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogHandle", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTableHandle" + } + } ] + }, { + "javaName" : "io.trino.metadata.IndexHandle", + "simpleName" : "IndexHandle", + "kind" : "record", + "properties" : [ { + "jsonName" : "catalogHandle", + "javaName" : "catalogHandle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogHandle", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorIndexHandle" + } + } ] + }, { + "javaName" : "io.trino.metadata.InsertTableHandle", + "simpleName" : "InsertTableHandle", + "kind" : "record", + "properties" : [ { + "jsonName" : "catalogHandle", + "javaName" : "catalogHandle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogHandle", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorInsertTableHandle" + } + } ] + }, { + "javaName" : "io.trino.metadata.LanguageFunctionDefinition", + "simpleName" : "LanguageFunctionDefinition", + "kind" : "record", + "properties" : [ { + "jsonName" : "language", + "javaName" : "language", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "returnType", + "javaName" : "returnType", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "argumentTypes", + "javaName" : "argumentTypes", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "definition", + "javaName" : "definition", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "properties", + "javaName" : "properties", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + } ] + }, { + "javaName" : "io.trino.metadata.LanguageFunctionProvider$LanguageFunctionData", + "simpleName" : "LanguageFunctionData", + "kind" : "record", + "properties" : [ { + "jsonName" : "irRoutine", + "javaName" : "irRoutine", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.routine.ir.IrRoutine" + } + } + }, { + "jsonName" : "definition", + "javaName" : "definition", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.metadata.LanguageFunctionDefinition" + } + } + } ] + }, { + "javaName" : "io.trino.metadata.OutputTableHandle", + "simpleName" : "OutputTableHandle", + "kind" : "record", + "properties" : [ { + "jsonName" : "catalogHandle", + "javaName" : "catalogHandle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogHandle", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "tableName", + "javaName" : "tableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.SchemaTableName" + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorOutputTableHandle" + } + } ] + }, { + "javaName" : "io.trino.metadata.ResolvedFunction", + "simpleName" : "ResolvedFunction", + "kind" : "record", + "properties" : [ { + "jsonName" : "signature", + "javaName" : "signature", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.function.BoundSignature" + } + }, { + "jsonName" : "catalogHandle", + "javaName" : "catalogHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogHandle", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "functionId", + "javaName" : "functionId", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.function.FunctionId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "functionKind", + "javaName" : "functionKind", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.spi.function.FunctionKind", + "enumValues" : [ "SCALAR", "AGGREGATE", "WINDOW", "TABLE" ] + } + }, { + "jsonName" : "deterministic", + "javaName" : "deterministic", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "neverFails", + "javaName" : "neverFails", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "functionNullability", + "javaName" : "functionNullability", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.function.FunctionNullability" + } + }, { + "jsonName" : "typeDependencies", + "javaName" : "typeDependencies", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeDescriptor", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "functionDependencies", + "javaName" : "functionDependencies", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.metadata.ResolvedFunction" + } + } + } ] + }, { + "javaName" : "io.trino.metadata.TableHandle", + "simpleName" : "TableHandle", + "kind" : "record", + "properties" : [ { + "jsonName" : "catalogHandle", + "javaName" : "catalogHandle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogHandle", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTableHandle" + } + }, { + "jsonName" : "transaction", + "javaName" : "transaction", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + } ] + }, { + "javaName" : "io.trino.operator.DriverStats", + "simpleName" : "DriverStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "createTime", + "javaName" : "createTime", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "startTime", + "javaName" : "startTime", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "endTime", + "javaName" : "endTime", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "spilledDataSize", + "javaName" : "spilledDataSize", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 12, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "rawInputReadTime", + "javaName" : "rawInputReadTime", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 20, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "inputBlockedTime", + "javaName" : "inputBlockedTime", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 23, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputBlockedTime", + "javaName" : "outputBlockedTime", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "operatorStats", + "javaName" : "operatorStats", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.OperatorStats" + } + } + } ] + }, { + "javaName" : "io.trino.operator.OperatorStats", + "simpleName" : "OperatorStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "stageId", + "javaName" : "stageId", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "pipelineId", + "javaName" : "pipelineId", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "operatorId", + "javaName" : "operatorId", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "planNodeId", + "javaName" : "planNodeId", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "sourceId", + "javaName" : "sourceId", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "operatorType", + "javaName" : "operatorType", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "addInputCalls", + "javaName" : "addInputCalls", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "addInputWall", + "javaName" : "addInputWall", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "addInputCpu", + "javaName" : "addInputCpu", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 12, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "inputDataSize", + "javaName" : "inputDataSize", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "inputPositions", + "javaName" : "inputPositions", + "creatorIndex" : 16, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "sumSquaredInputPositions", + "javaName" : "sumSquaredInputPositions", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "getOutputCalls", + "javaName" : "getOutputCalls", + "creatorIndex" : 18, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "getOutputWall", + "javaName" : "getOutputWall", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "getOutputCpu", + "javaName" : "getOutputCpu", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 22, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "dynamicFilterSplitsProcessed", + "javaName" : "dynamicFilterSplitsProcessed", + "creatorIndex" : 23, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "metrics", + "javaName" : "metrics", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.metrics.Metrics", + "elementType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.metrics.Metric" + } + } + } + }, { + "jsonName" : "connectorMetrics", + "javaName" : "connectorMetrics", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.metrics.Metrics", + "elementType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.metrics.Metric" + } + } + } + }, { + "jsonName" : "pipelineMetrics", + "javaName" : "pipelineMetrics", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.metrics.Metrics", + "elementType" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.metrics.Metric" + } + } + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "blockedWall", + "javaName" : "blockedWall", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "finishCalls", + "javaName" : "finishCalls", + "creatorIndex" : 29, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "finishWall", + "javaName" : "finishWall", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "finishCpu", + "javaName" : "finishCpu", + "creatorIndex" : 31, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 33, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakRevocableMemoryReservation", + "javaName" : "peakRevocableMemoryReservation", + "creatorIndex" : 35, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "spilledDataSize", + "javaName" : "spilledDataSize", + "creatorIndex" : 36, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "blockedReason", + "javaName" : "blockedReason", + "creatorIndex" : 37, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "info", + "javaName" : "info", + "creatorIndex" : 38, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "io.trino.operator.OperatorInfo" + } + } ] + }, { + "javaName" : "io.trino.operator.PageBufferClientStatus", + "simpleName" : "PageBufferClientStatus", + "kind" : "class", + "properties" : [ { + "jsonName" : "uri", + "javaName" : "uri", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "lastUpdate", + "javaName" : "lastUpdate", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "rowsReceived", + "javaName" : "rowsReceived", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "pagesReceived", + "javaName" : "pagesReceived", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "rowsRejected", + "javaName" : "rowsRejected", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Long" + } + } + }, { + "jsonName" : "pagesRejected", + "javaName" : "pagesRejected", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "requestsScheduled", + "javaName" : "requestsScheduled", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "requestsCompleted", + "javaName" : "requestsCompleted", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "requestsFailed", + "javaName" : "requestsFailed", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "requestsSucceeded", + "javaName" : "requestsSucceeded", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "httpRequestState", + "javaName" : "httpRequestState", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.operator.PipelineStats", + "simpleName" : "PipelineStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "pipelineId", + "javaName" : "pipelineId", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "firstStartTime", + "javaName" : "firstStartTime", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "lastStartTime", + "javaName" : "lastStartTime", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "lastEndTime", + "javaName" : "lastEndTime", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "inputPipeline", + "javaName" : "inputPipeline", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "outputPipeline", + "javaName" : "outputPipeline", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedPartitionedDrivers", + "javaName" : "queuedPartitionedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedPartitionedSplitsWeight", + "javaName" : "queuedPartitionedSplitsWeight", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningPartitionedDrivers", + "javaName" : "runningPartitionedDrivers", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningPartitionedSplitsWeight", + "javaName" : "runningPartitionedSplitsWeight", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 13, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "spilledDataSize", + "javaName" : "spilledDataSize", + "creatorIndex" : 17, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.airlift.stats.Distribution$DistributionSnapshot" + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.airlift.stats.Distribution$DistributionSnapshot" + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 23, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 26, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 29, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 31, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "inputBlockedTime", + "javaName" : "inputBlockedTime", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 33, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 34, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputBlockedTime", + "javaName" : "outputBlockedTime", + "creatorIndex" : 35, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 36, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "operatorSummaries", + "javaName" : "operatorSummaries", + "creatorIndex" : 37, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.OperatorStats" + } + } + }, { + "jsonName" : "drivers", + "javaName" : "drivers", + "creatorIndex" : 38, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.DriverStats" + } + } + } ] + }, { + "javaName" : "io.trino.operator.TableFinishInfo", + "simpleName" : "TableFinishInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "connectorOutputMetadata", + "javaName" : "connectorOutputMetadata", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "com.fasterxml.jackson.databind.JsonNode" + } + }, { + "jsonName" : "jsonLengthLimitExceeded", + "javaName" : "jsonLengthLimitExceeded", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "statisticsWallTime", + "javaName" : "statisticsWallTime", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "statisticsCpuTime", + "javaName" : "statisticsCpuTime", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.operator.TableWriterOperator$TableWriterInfo", + "simpleName" : "TableWriterInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "pageSinkPeakMemoryUsage", + "javaName" : "pageSinkPeakMemoryUsage", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "statisticsWallTime", + "javaName" : "statisticsWallTime", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "statisticsCpuTime", + "javaName" : "statisticsCpuTime", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "validationCpuTime", + "javaName" : "validationCpuTime", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.operator.TaskStats", + "simpleName" : "TaskStats", + "kind" : "record", + "properties" : [ { + "jsonName" : "createTime", + "javaName" : "createTime", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "firstStartTime", + "javaName" : "firstStartTime", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "lastStartTime", + "javaName" : "lastStartTime", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "terminatingStartTime", + "javaName" : "terminatingStartTime", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "lastEndTime", + "javaName" : "lastEndTime", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "endTime", + "javaName" : "endTime", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 7, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedPartitionedDrivers", + "javaName" : "queuedPartitionedDrivers", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedPartitionedSplitsWeight", + "javaName" : "queuedPartitionedSplitsWeight", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningPartitionedDrivers", + "javaName" : "runningPartitionedDrivers", + "creatorIndex" : 13, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningPartitionedSplitsWeight", + "javaName" : "runningPartitionedSplitsWeight", + "creatorIndex" : 14, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 15, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 16, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "cumulativeUserMemory", + "javaName" : "cumulativeUserMemory", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 18, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "revocableMemoryReservation", + "javaName" : "revocableMemoryReservation", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "spilledDataSize", + "javaName" : "spilledDataSize", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalBlockedTime", + "javaName" : "totalBlockedTime", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 25, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputPositions", + "javaName" : "physicalInputPositions", + "creatorIndex" : 28, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 29, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputPositions", + "javaName" : "internalNetworkInputPositions", + "creatorIndex" : 31, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "processedInputDataSize", + "javaName" : "processedInputDataSize", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 33, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "inputBlockedTime", + "javaName" : "inputBlockedTime", + "creatorIndex" : 34, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputDataSize", + "javaName" : "outputDataSize", + "creatorIndex" : 35, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputPositions", + "javaName" : "outputPositions", + "creatorIndex" : 36, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "outputBlockedTime", + "javaName" : "outputBlockedTime", + "creatorIndex" : 37, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "writerInputDataSize", + "javaName" : "writerInputDataSize", + "creatorIndex" : 38, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 39, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "maxWriterCount", + "javaName" : "maxWriterCount", + "creatorIndex" : 40, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "fullGcCount", + "javaName" : "fullGcCount", + "creatorIndex" : 41, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "fullGcTime", + "javaName" : "fullGcTime", + "creatorIndex" : 42, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "pipelines", + "javaName" : "pipelines", + "creatorIndex" : 43, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.PipelineStats" + } + } + } ] + }, { + "javaName" : "io.trino.operator.WindowInfo", + "simpleName" : "WindowInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "windowInfos", + "javaName" : "windowInfos", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.operator.WindowInfo$DriverWindowInfo" + } + } + } ] + }, { + "javaName" : "io.trino.operator.WindowInfo$DriverWindowInfo", + "simpleName" : "DriverWindowInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "sumSquaredDifferencesPositionsOfIndex", + "javaName" : "sumSquaredDifferencesPositionsOfIndex", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "sumSquaredDifferencesSizeOfIndex", + "javaName" : "sumSquaredDifferencesSizeOfIndex", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "sumSquaredDifferencesSizeInPartition", + "javaName" : "sumSquaredDifferencesSizeInPartition", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "totalPartitionsCount", + "javaName" : "totalPartitionsCount", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalRowsCount", + "javaName" : "totalRowsCount", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "numberOfIndexes", + "javaName" : "numberOfIndexes", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + } ] + }, { + "javaName" : "io.trino.operator.exchange.LocalExchangeBufferInfo", + "simpleName" : "LocalExchangeBufferInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "bufferedBytes", + "javaName" : "bufferedBytes", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "bufferedPages", + "javaName" : "bufferedPages", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.plugin.base.metrics.DistributionSnapshot", + "simpleName" : "DistributionSnapshot", + "kind" : "record", + "properties" : [ { + "jsonName" : "total", + "javaName" : "total", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "min", + "javaName" : "min", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "max", + "javaName" : "max", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p01", + "javaName" : "p01", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p05", + "javaName" : "p05", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p10", + "javaName" : "p10", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p25", + "javaName" : "p25", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p50", + "javaName" : "p50", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p75", + "javaName" : "p75", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p90", + "javaName" : "p90", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p95", + "javaName" : "p95", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "p99", + "javaName" : "p99", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + } ] + }, { + "javaName" : "io.trino.plugin.base.metrics.TDigestHistogram", + "simpleName" : "TDigestHistogram", + "kind" : "class", + "properties" : [ { + "jsonName" : "digest", + "javaName" : "digest", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "array", + "elementType" : { + "kind" : "primitive", + "name" : "byte" + } + } + } ] + }, { + "javaName" : "io.trino.server.BasicQueryInfo", + "simpleName" : "BasicQueryInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "queryId", + "javaName" : "queryId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.QueryId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "session", + "javaName" : "session", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.SessionRepresentation" + } + }, { + "jsonName" : "resourceGroupId", + "javaName" : "resourceGroupId", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.resourcegroups.ResourceGroupId", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + }, { + "jsonName" : "state", + "javaName" : "state", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.execution.QueryState", + "enumValues" : [ "QUEUED", "WAITING_FOR_RESOURCES", "DISPATCHING", "PLANNING", "STARTING", "RUNNING", "FINISHING", "FINISHED", "FAILED" ] + } + }, { + "jsonName" : "scheduled", + "javaName" : "scheduled", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "self", + "javaName" : "self", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.net.URI" + } + }, { + "jsonName" : "query", + "javaName" : "query", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "updateType", + "javaName" : "updateType", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "preparedQuery", + "javaName" : "preparedQuery", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "queryStats", + "javaName" : "queryStats", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.server.BasicQueryStats" + } + }, { + "jsonName" : "errorType", + "javaName" : "errorType", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "enum", + "name" : "io.trino.spi.ErrorType", + "enumValues" : [ "USER_ERROR", "INTERNAL_ERROR", "INSUFFICIENT_RESOURCES", "EXTERNAL" ] + } + }, { + "jsonName" : "errorCode", + "javaName" : "errorCode", + "creatorIndex" : 11, + "nullability" : "nullable", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.ErrorCode" + } + }, { + "jsonName" : "queryType", + "javaName" : "queryType", + "creatorIndex" : 12, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.spi.resourcegroups.QueryType", + "enumValues" : [ "SELECT", "EXPLAIN", "DESCRIBE", "INSERT", "UPDATE", "DELETE", "ANALYZE", "DATA_DEFINITION", "ALTER_TABLE_EXECUTE", "MERGE" ] + } + } + }, { + "jsonName" : "retryPolicy", + "javaName" : "retryPolicy", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.operator.RetryPolicy", + "enumValues" : [ "TASK", "QUERY", "NONE" ] + } + } ] + }, { + "javaName" : "io.trino.server.BasicQueryStats", + "simpleName" : "BasicQueryStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "createTime", + "javaName" : "createTime", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "endTime", + "javaName" : "endTime", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.time.Instant" + } + }, { + "jsonName" : "queuedTime", + "javaName" : "queuedTime", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "resourceWaitingTime", + "javaName" : "resourceWaitingTime", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "elapsedTime", + "javaName" : "elapsedTime", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "executionTime", + "javaName" : "executionTime", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedTasks", + "javaName" : "failedTasks", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalDrivers", + "javaName" : "totalDrivers", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "queuedDrivers", + "javaName" : "queuedDrivers", + "creatorIndex" : 8, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "runningDrivers", + "javaName" : "runningDrivers", + "creatorIndex" : 9, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "completedDrivers", + "javaName" : "completedDrivers", + "creatorIndex" : 10, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "blockedDrivers", + "javaName" : "blockedDrivers", + "creatorIndex" : 11, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "processedInputPositions", + "javaName" : "processedInputPositions", + "creatorIndex" : 12, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "spilledDataSize", + "javaName" : "spilledDataSize", + "creatorIndex" : 13, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputDataSize", + "javaName" : "physicalInputDataSize", + "creatorIndex" : 14, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalWrittenDataSize", + "javaName" : "physicalWrittenDataSize", + "creatorIndex" : 15, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "internalNetworkInputDataSize", + "javaName" : "internalNetworkInputDataSize", + "creatorIndex" : 16, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "cumulativeUserMemory", + "javaName" : "cumulativeUserMemory", + "creatorIndex" : 17, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "failedCumulativeUserMemory", + "javaName" : "failedCumulativeUserMemory", + "creatorIndex" : 18, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "userMemoryReservation", + "javaName" : "userMemoryReservation", + "creatorIndex" : 19, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalMemoryReservation", + "javaName" : "totalMemoryReservation", + "creatorIndex" : 20, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakUserMemoryReservation", + "javaName" : "peakUserMemoryReservation", + "creatorIndex" : 21, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "peakTotalMemoryReservation", + "javaName" : "peakTotalMemoryReservation", + "creatorIndex" : 22, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.DataSize", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "planningTime", + "javaName" : "planningTime", + "creatorIndex" : 23, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "analysisTime", + "javaName" : "analysisTime", + "creatorIndex" : 24, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalCpuTime", + "javaName" : "totalCpuTime", + "creatorIndex" : 25, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedCpuTime", + "javaName" : "failedCpuTime", + "creatorIndex" : 26, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "totalScheduledTime", + "javaName" : "totalScheduledTime", + "creatorIndex" : 27, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "failedScheduledTime", + "javaName" : "failedScheduledTime", + "creatorIndex" : 28, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "finishingTime", + "javaName" : "finishingTime", + "creatorIndex" : 29, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "physicalInputReadTime", + "javaName" : "physicalInputReadTime", + "creatorIndex" : 30, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "fullyBlocked", + "javaName" : "fullyBlocked", + "creatorIndex" : 31, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "blockedReasons", + "javaName" : "blockedReasons", + "creatorIndex" : 32, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.operator.BlockedReason", + "enumValues" : [ "WAITING_FOR_MEMORY" ] + } + } + }, { + "jsonName" : "progressPercentage", + "javaName" : "progressPercentage", + "creatorIndex" : 33, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Double" + } + } + }, { + "jsonName" : "runningPercentage", + "javaName" : "runningPercentage", + "creatorIndex" : 34, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Double" + } + } + } ] + }, { + "javaName" : "io.trino.server.DynamicFilterService$DynamicFilterDomainStats", + "simpleName" : "DynamicFilterDomainStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "dynamicFilterId", + "javaName" : "dynamicFilterId", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.DynamicFilterId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "simplifiedDomain", + "javaName" : "simplifiedDomain", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "collectionDuration", + "javaName" : "collectionDuration", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.airlift.units.Duration", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.server.DynamicFilterService$DynamicFiltersStats", + "simpleName" : "DynamicFiltersStats", + "kind" : "class", + "properties" : [ { + "jsonName" : "dynamicFilterDomainStats", + "javaName" : "dynamicFilterDomainStats", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.server.DynamicFilterService$DynamicFilterDomainStats" + } + } + }, { + "jsonName" : "lazyDynamicFilters", + "javaName" : "lazyDynamicFilters", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "replicatedDynamicFilters", + "javaName" : "replicatedDynamicFilters", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalDynamicFilters", + "javaName" : "totalDynamicFilters", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "dynamicFiltersCompleted", + "javaName" : "dynamicFiltersCompleted", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.spi.ErrorCode", + "simpleName" : "ErrorCode", + "kind" : "class", + "properties" : [ { + "jsonName" : "code", + "javaName" : "code", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.spi.ErrorType", + "enumValues" : [ "USER_ERROR", "INTERNAL_ERROR", "INSUFFICIENT_RESOURCES", "EXTERNAL" ] + } + }, { + "jsonName" : "fatal", + "javaName" : "fatal", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.spi.NodeVersion", + "simpleName" : "NodeVersion", + "kind" : "record", + "properties" : [ { + "jsonName" : "version", + "javaName" : "version", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.TrinoWarning", + "simpleName" : "TrinoWarning", + "kind" : "class", + "properties" : [ { + "jsonName" : "warningCode", + "javaName" : "warningCode", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.WarningCode" + } + }, { + "jsonName" : "message", + "javaName" : "message", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.WarningCode", + "simpleName" : "WarningCode", + "kind" : "class", + "properties" : [ { + "jsonName" : "code", + "javaName" : "code", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.catalog.CatalogProperties", + "simpleName" : "CatalogProperties", + "kind" : "record", + "properties" : [ { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.catalog.CatalogName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "version", + "javaName" : "version", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.connector.CatalogVersion", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "connectorName", + "javaName" : "connectorName", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.connector.ConnectorName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "properties", + "javaName" : "properties", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.spi.connector.CatalogSchemaName", + "simpleName" : "CatalogSchemaName", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "schemaName", + "javaName" : "schemaName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.connector.SchemaTableName", + "simpleName" : "SchemaTableName", + "kind" : "class", + "properties" : [ { + "jsonName" : "schema", + "javaName" : "schemaName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "tableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.connector.WriterScalingOptions", + "simpleName" : "WriterScalingOptions", + "kind" : "record", + "properties" : [ { + "jsonName" : "isWriterTasksScalingEnabled", + "javaName" : "isWriterTasksScalingEnabled", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "isPerTaskWriterScalingEnabled", + "javaName" : "isPerTaskWriterScalingEnabled", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "perTaskMaxScaledWriterCount", + "javaName" : "perTaskMaxScaledWriterCount", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.ColumnDetail", + "simpleName" : "ColumnDetail", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalog", + "javaName" : "catalog", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "columnName", + "javaName" : "columnName", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.ColumnInfo", + "simpleName" : "ColumnInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "column", + "javaName" : "column", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "mask", + "javaName" : "mask", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.ColumnLineageInfo", + "simpleName" : "ColumnLineageInfo", + "kind" : "record", + "properties" : [ { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "sourceColumns", + "javaName" : "sourceColumns", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.ColumnDetail" + } + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.QueryPlanOptimizerStatistics", + "simpleName" : "QueryPlanOptimizerStatistics", + "kind" : "record", + "properties" : [ { + "jsonName" : "rule", + "javaName" : "rule", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "invocations", + "javaName" : "invocations", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "applied", + "javaName" : "applied", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "totalTime", + "javaName" : "totalTime", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "failures", + "javaName" : "failures", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.RoutineInfo", + "simpleName" : "RoutineInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "routine", + "javaName" : "routine", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "authorization", + "javaName" : "authorization", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.StageGcStatistics", + "simpleName" : "StageGcStatistics", + "kind" : "class", + "properties" : [ { + "jsonName" : "stageId", + "javaName" : "stageId", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "tasks", + "javaName" : "tasks", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "fullGcTasks", + "javaName" : "fullGcTasks", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "minFullGcSec", + "javaName" : "minFullGcSec", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "maxFullGcSec", + "javaName" : "maxFullGcSec", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "totalFullGcSec", + "javaName" : "totalFullGcSec", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "averageFullGcSec", + "javaName" : "averageFullGcSec", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.spi.eventlistener.TableInfo", + "simpleName" : "TableInfo", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalog", + "javaName" : "catalog", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "authorization", + "javaName" : "authorization", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "filters", + "javaName" : "filters", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.eventlistener.ColumnInfo" + } + } + }, { + "jsonName" : "directlyReferenced", + "javaName" : "directlyReferenced", + "creatorIndex" : 6, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "viewText", + "javaName" : "viewText", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "referenceChain", + "javaName" : "referenceChain", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.spi.eventlistener.TableReferenceInfo" + } + } + } ] + }, { + "javaName" : "io.trino.spi.expression.FunctionName", + "simpleName" : "FunctionName", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogSchema", + "javaName" : "catalogSchema", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.connector.CatalogSchemaName" + } + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.function.BoundSignature", + "simpleName" : "BoundSignature", + "kind" : "class", + "properties" : [ { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.function.CatalogSchemaFunctionName" + } + }, { + "jsonName" : "returnType", + "javaName" : "returnType", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "argumentTypes", + "javaName" : "argumentTypes", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } + } ] + }, { + "javaName" : "io.trino.spi.function.CatalogSchemaFunctionName", + "simpleName" : "CatalogSchemaFunctionName", + "kind" : "record", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "schemaName", + "javaName" : "schemaName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "functionName", + "javaName" : "functionName", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.spi.function.FunctionNullability", + "simpleName" : "FunctionNullability", + "kind" : "class", + "properties" : [ { + "jsonName" : "returnNullable", + "javaName" : "returnNullable", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "argumentNullable", + "javaName" : "argumentNullable", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Boolean" + } + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.Domain", + "simpleName" : "Domain", + "kind" : "class", + "properties" : [ { + "jsonName" : "values", + "javaName" : "values", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.predicate.ValueSet" + } + }, { + "jsonName" : "nullAllowed", + "javaName" : "nullAllowed", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.NullableValue", + "simpleName" : "NullableValue", + "kind" : "class", + "properties" : [ { + "jsonName" : "serializable", + "javaName" : "serializable", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.NullableValue$Serializable" + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.NullableValue$Serializable", + "simpleName" : "Serializable", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "block", + "javaName" : "block", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.block.Block" + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.TupleDomain", + "simpleName" : "TupleDomain", + "kind" : "class", + "properties" : [ { + "jsonName" : "columnDomains", + "javaName" : "columnDomains", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.TupleDomain$ColumnDomain" + } + } + } + } ] + }, { + "javaName" : "io.trino.spi.predicate.TupleDomain$ColumnDomain", + "simpleName" : "ColumnDomain", + "kind" : "class", + "properties" : [ { + "jsonName" : "column", + "javaName" : "column", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + }, { + "jsonName" : "domain", + "javaName" : "domain", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.Domain" + } + } ] + }, { + "javaName" : "io.trino.spi.security.SelectedRole", + "simpleName" : "SelectedRole", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.spi.security.SelectedRole$Type", + "enumValues" : [ "ROLE", "ALL", "NONE" ] + } + }, { + "jsonName" : "role", + "javaName" : "role", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.spi.session.ResourceEstimates", + "simpleName" : "ResourceEstimates", + "kind" : "class", + "properties" : [ { + "jsonName" : "executionTime", + "javaName" : "executionTime", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "java.time.Duration" + } + } + }, { + "jsonName" : "cpuTime", + "javaName" : "cpuTime", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "java.time.Duration" + } + } + }, { + "jsonName" : "peakMemoryBytes", + "javaName" : "peakMemoryBytes", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Long" + } + } + } ] + }, { + "javaName" : "io.trino.spi.statistics.ColumnStatisticMetadata", + "simpleName" : "ColumnStatisticMetadata", + "kind" : "class", + "properties" : [ { + "jsonName" : "columnName", + "javaName" : "columnName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "connectorAggregationId", + "javaName" : "connectorAggregationId", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "statisticType", + "javaName" : "statisticType", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.spi.statistics.ColumnStatisticType", + "enumValues" : [ "MIN_VALUE", "MAX_VALUE", "NUMBER_OF_DISTINCT_VALUES", "NUMBER_OF_DISTINCT_VALUES_SUMMARY", "NUMBER_OF_NON_NULL_VALUES", "NUMBER_OF_TRUE_VALUES", "MAX_VALUE_SIZE_IN_BYTES", "TOTAL_SIZE_IN_BYTES" ] + } + } + }, { + "jsonName" : "aggregation", + "javaName" : "aggregation", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.expression.FunctionName" + } + } + } ] + }, { + "javaName" : "io.trino.sql.SqlPath", + "simpleName" : "SqlPath", + "kind" : "class", + "properties" : [ { + "jsonName" : "path", + "javaName" : "path", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.connector.CatalogSchemaName" + } + } + }, { + "jsonName" : "rawPath", + "javaName" : "rawPath", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.sql.analyzer.Analysis$SourceColumn", + "simpleName" : "SourceColumn", + "kind" : "class", + "properties" : [ { + "jsonName" : "tableName", + "javaName" : "tableName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.metadata.QualifiedObjectName", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "columnName", + "javaName" : "columnName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.sql.analyzer.Output", + "simpleName" : "Output", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogName", + "javaName" : "catalogName", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "catalogVersion", + "javaName" : "catalogVersion", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.connector.CatalogVersion", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "schema", + "javaName" : "schema", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.analyzer.OutputColumn" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.analyzer.OutputColumn", + "simpleName" : "OutputColumn", + "kind" : "class", + "properties" : [ { + "jsonName" : "column", + "javaName" : "column", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.execution.Column" + } + }, { + "jsonName" : "sourceColumns", + "javaName" : "sourceColumns", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.analyzer.Analysis$SourceColumn" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.OrderingScheme", + "simpleName" : "OrderingScheme", + "kind" : "record", + "properties" : [ { + "jsonName" : "orderBy", + "javaName" : "orderBy", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "orderings", + "javaName" : "orderings", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "enum", + "name" : "io.trino.spi.connector.SortOrder", + "enumValues" : [ "ASC NULLS FIRST", "ASC NULLS LAST", "DESC NULLS FIRST", "DESC NULLS LAST" ] + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.Partitioning", + "simpleName" : "Partitioning", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningHandle" + } + }, { + "jsonName" : "arguments", + "javaName" : "arguments", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Partitioning$ArgumentBinding" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.Partitioning$ArgumentBinding", + "simpleName" : "ArgumentBinding", + "kind" : "class", + "properties" : [ { + "jsonName" : "expression", + "javaName" : "expression", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + }, { + "jsonName" : "constant", + "javaName" : "constant", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.predicate.NullableValue" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.PartitioningHandle", + "simpleName" : "PartitioningHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "catalogHandle", + "javaName" : "catalogHandle", + "creatorIndex" : 0, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.connector.CatalogHandle", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "transactionHandle", + "javaName" : "transactionHandle", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorTransactionHandle" + } + } + }, { + "jsonName" : "connectorHandle", + "javaName" : "connectorHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ConnectorPartitioningHandle" + } + }, { + "jsonName" : "scaleWriters", + "javaName" : "scaleWriters", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.PartitioningScheme", + "simpleName" : "PartitioningScheme", + "kind" : "class", + "properties" : [ { + "jsonName" : "partitioning", + "javaName" : "partitioning", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Partitioning" + } + }, { + "jsonName" : "outputLayout", + "javaName" : "outputLayout", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "replicateNullsAndAny", + "javaName" : "replicateNullsAndAny", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "bucketToPartition", + "javaName" : "bucketToPartition", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "array", + "elementType" : { + "kind" : "primitive", + "name" : "int" + } + } + } + }, { + "jsonName" : "bucketCount", + "javaName" : "bucketCount", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "partitionCount", + "javaName" : "partitionCount", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.PlanFragment", + "simpleName" : "PlanFragment", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanFragmentId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "root", + "javaName" : "root", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "symbols", + "javaName" : "symbols", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "partitioning", + "javaName" : "partitioning", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningHandle" + } + }, { + "jsonName" : "partitionCount", + "javaName" : "partitionCount", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "partitionedSources", + "javaName" : "partitionedSources", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "outputPartitioningScheme", + "javaName" : "outputPartitioningScheme", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningScheme" + } + }, { + "jsonName" : "outputSkewedBucketCount", + "javaName" : "outputSkewedBucketCount", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "statsAndCosts", + "javaName" : "statsAndCosts", + "creatorIndex" : 8, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.cost.StatsAndCosts" + } + }, { + "jsonName" : "activeCatalogs", + "javaName" : "activeCatalogs", + "creatorIndex" : 9, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.spi.catalog.CatalogProperties" + } + } + }, { + "jsonName" : "languageFunctions", + "javaName" : "languageFunctions", + "creatorIndex" : 10, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.spi.function.FunctionId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.metadata.LanguageFunctionProvider$LanguageFunctionData" + } + } + }, { + "jsonName" : "jsonRepresentation", + "javaName" : "jsonRepresentation", + "creatorIndex" : 11, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.Symbol", + "simpleName" : "Symbol", + "kind" : "record", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "name", + "javaName" : "name", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.AggregationNode", + "simpleName" : "AggregationNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "aggregations", + "javaName" : "aggregations", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.AggregationNode$Aggregation" + } + } + }, { + "jsonName" : "groupingSets", + "javaName" : "groupingSets", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.AggregationNode$GroupingSetDescriptor" + } + }, { + "jsonName" : "preGroupedSymbols", + "javaName" : "preGroupedSymbols", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "step", + "javaName" : "step", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.AggregationNode$Step", + "enumValues" : [ "PARTIAL", "FINAL", "INTERMEDIATE", "SINGLE" ] + } + }, { + "jsonName" : "groupIdSymbol", + "javaName" : "groupIdSymbol", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "isInputReducingAggregation", + "javaName" : "isInputReducingAggregation", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Boolean" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.AggregationNode$Aggregation", + "simpleName" : "Aggregation", + "kind" : "class", + "properties" : [ { + "jsonName" : "resolvedFunction", + "javaName" : "resolvedFunction", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.ResolvedFunction" + } + }, { + "jsonName" : "arguments", + "javaName" : "arguments", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + } + }, { + "jsonName" : "distinct", + "javaName" : "distinct", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + }, { + "jsonName" : "mask", + "javaName" : "mask", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.AggregationNode$GroupingSetDescriptor", + "simpleName" : "GroupingSetDescriptor", + "kind" : "class", + "properties" : [ { + "jsonName" : "groupingKeys", + "javaName" : "groupingKeys", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "groupingSetCount", + "javaName" : "groupingSetCount", + "creatorIndex" : 1, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "globalGroupingSets", + "javaName" : "globalGroupingSets", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ApplyNode", + "simpleName" : "ApplyNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "input", + "javaName" : "input", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "subquery", + "javaName" : "subquery", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "subqueryAssignments", + "javaName" : "subqueryAssignments", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.ApplyNode$SetExpression" + } + } + }, { + "jsonName" : "correlation", + "javaName" : "correlation", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "originSubquery", + "javaName" : "originSubquery", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Node" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.AssignUniqueId", + "simpleName" : "AssignUniqueId", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "idColumn", + "javaName" : "idColumn", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.Assignments", + "simpleName" : "Assignments", + "kind" : "record", + "properties" : [ { + "jsonName" : "assignments", + "javaName" : "assignments", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.CorrelatedJoinNode", + "simpleName" : "CorrelatedJoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "input", + "javaName" : "input", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "subquery", + "javaName" : "subquery", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "correlation", + "javaName" : "correlation", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.JoinType", + "enumValues" : [ "INNER", "LEFT", "RIGHT", "FULL" ] + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + }, { + "jsonName" : "originSubquery", + "javaName" : "originSubquery", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.tree.Node" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.DataOrganizationSpecification", + "simpleName" : "DataOrganizationSpecification", + "kind" : "record", + "properties" : [ { + "jsonName" : "partitionBy", + "javaName" : "partitionBy", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 1, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.DistinctLimitNode", + "simpleName" : "DistinctLimitNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "limit", + "javaName" : "limit", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "partial", + "javaName" : "partial", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "distinctSymbols", + "javaName" : "distinctSymbols", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.EnforceSingleRowNode", + "simpleName" : "EnforceSingleRowNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ExchangeNode", + "simpleName" : "ExchangeNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.ExchangeNode$Type", + "enumValues" : [ "GATHER", "REPARTITION", "REPLICATE" ] + } + }, { + "jsonName" : "scope", + "javaName" : "scope", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.ExchangeNode$Scope", + "enumValues" : [ "LOCAL", "REMOTE" ] + } + }, { + "jsonName" : "partitioningScheme", + "javaName" : "partitioningScheme", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningScheme" + } + }, { + "jsonName" : "sources", + "javaName" : "sources", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + } + }, { + "jsonName" : "inputs", + "javaName" : "inputs", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ExplainAnalyzeNode", + "simpleName" : "ExplainAnalyzeNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "outputSymbol", + "javaName" : "outputSymbol", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "actualOutputs", + "javaName" : "actualOutputs", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "verbose", + "javaName" : "verbose", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.FilterNode", + "simpleName" : "FilterNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "predicate", + "javaName" : "predicate", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.GroupIdNode", + "simpleName" : "GroupIdNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "groupingSets", + "javaName" : "groupingSets", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } + }, { + "jsonName" : "groupingColumns", + "javaName" : "groupingColumns", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "aggregationArguments", + "javaName" : "aggregationArguments", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "groupIdSymbol", + "javaName" : "groupIdSymbol", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.IndexJoinNode", + "simpleName" : "IndexJoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.IndexJoinNode$Type", + "enumValues" : [ "INNER", "SOURCE_OUTER" ] + } + }, { + "jsonName" : "probeSource", + "javaName" : "probeSource", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "indexSource", + "javaName" : "indexSource", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "criteria", + "javaName" : "criteria", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.IndexJoinNode$EquiJoinClause" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.IndexJoinNode$EquiJoinClause", + "simpleName" : "EquiJoinClause", + "kind" : "class", + "properties" : [ { + "jsonName" : "probe", + "javaName" : "probe", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "index", + "javaName" : "index", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.IndexSourceNode", + "simpleName" : "IndexSourceNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "indexHandle", + "javaName" : "indexHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.IndexHandle" + } + }, { + "jsonName" : "tableHandle", + "javaName" : "tableHandle", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + }, { + "jsonName" : "lookupSymbols", + "javaName" : "lookupSymbols", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "assignments", + "javaName" : "assignments", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ColumnHandle" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.IntersectNode", + "simpleName" : "IntersectNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "sources", + "javaName" : "sources", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + } + }, { + "jsonName" : "outputToInputs", + "javaName" : "outputToInputs", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "com.google.common.collect.ListMultimap" + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "distinct", + "javaName" : "distinct", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.JoinNode", + "simpleName" : "JoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.JoinType", + "enumValues" : [ "INNER", "LEFT", "RIGHT", "FULL" ] + } + }, { + "jsonName" : "left", + "javaName" : "left", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "right", + "javaName" : "right", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "criteria", + "javaName" : "criteria", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.JoinNode$EquiJoinClause" + } + } + }, { + "jsonName" : "leftOutputSymbols", + "javaName" : "leftOutputSymbols", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "rightOutputSymbols", + "javaName" : "rightOutputSymbols", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "maySkipOutputDuplicates", + "javaName" : "maySkipOutputDuplicates", + "creatorIndex" : 7, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + } + }, { + "jsonName" : "distributionType", + "javaName" : "distributionType", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.JoinNode$DistributionType", + "enumValues" : [ "PARTITIONED", "REPLICATED" ] + } + } + }, { + "jsonName" : "spillable", + "javaName" : "spillable", + "creatorIndex" : 10, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Boolean" + } + } + }, { + "jsonName" : "dynamicFilters", + "javaName" : "dynamicFilters", + "creatorIndex" : 11, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.DynamicFilterId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "reorderJoinStatsAndCost", + "javaName" : "reorderJoinStatsAndCost", + "creatorIndex" : 12, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.cost.PlanNodeStatsAndCostSummary" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.JoinNode$EquiJoinClause", + "simpleName" : "EquiJoinClause", + "kind" : "class", + "properties" : [ { + "jsonName" : "left", + "javaName" : "left", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "right", + "javaName" : "right", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.LimitNode", + "simpleName" : "LimitNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "count", + "javaName" : "count", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "tiesResolvingScheme", + "javaName" : "tiesResolvingScheme", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + }, { + "jsonName" : "partial", + "javaName" : "partial", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "requiresPreSortedInputs", + "javaName" : "preSortedInputs", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.MarkDistinctNode", + "simpleName" : "MarkDistinctNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "markerSymbol", + "javaName" : "markerSymbol", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "distinctSymbols", + "javaName" : "distinctSymbols", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.OutputNode", + "simpleName" : "OutputNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "columns", + "javaName" : "columnNames", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ProjectNode", + "simpleName" : "ProjectNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "assignments", + "javaName" : "assignments", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.Assignments" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.RemoteSourceNode", + "simpleName" : "RemoteSourceNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "sourceFragmentIds", + "javaName" : "sourceFragmentIds", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanFragmentId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + }, { + "jsonName" : "exchangeType", + "javaName" : "exchangeType", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.ExchangeNode$Type", + "enumValues" : [ "GATHER", "REPARTITION", "REPLICATE" ] + } + }, { + "jsonName" : "retryPolicy", + "javaName" : "retryPolicy", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.operator.RetryPolicy", + "enumValues" : [ "TASK", "QUERY", "NONE" ] + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.RowNumberNode", + "simpleName" : "RowNumberNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "partitionBy", + "javaName" : "partitionBy", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "orderSensitive", + "javaName" : "orderSensitive", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "rowNumberSymbol", + "javaName" : "rowNumberSymbol", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "maxRowCountPerPartition", + "javaName" : "maxRowCountPerPartition", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.SampleNode", + "simpleName" : "SampleNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "sampleRatio", + "javaName" : "sampleRatio", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "double" + } + }, { + "jsonName" : "sampleType", + "javaName" : "sampleType", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.SampleNode$Type", + "enumValues" : [ "BERNOULLI", "SYSTEM" ] + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.SemiJoinNode", + "simpleName" : "SemiJoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "filteringSource", + "javaName" : "filteringSource", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "sourceJoinSymbol", + "javaName" : "sourceJoinSymbol", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "filteringSourceJoinSymbol", + "javaName" : "filteringSourceJoinSymbol", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "semiJoinOutput", + "javaName" : "semiJoinOutput", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "distributionType", + "javaName" : "distributionType", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.SemiJoinNode$DistributionType", + "enumValues" : [ "PARTITIONED", "REPLICATED" ] + } + } + }, { + "jsonName" : "dynamicFilterId", + "javaName" : "dynamicFilterId", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.DynamicFilterId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.SortNode", + "simpleName" : "SortNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + }, { + "jsonName" : "partial", + "javaName" : "partial", + "creatorIndex" : 3, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.SpatialJoinNode", + "simpleName" : "SpatialJoinNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.SpatialJoinNode$Type", + "enumValues" : [ "INNER", "LEFT" ] + } + }, { + "jsonName" : "left", + "javaName" : "left", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "right", + "javaName" : "right", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "filter", + "javaName" : "filter", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + }, { + "jsonName" : "leftPartitionSymbol", + "javaName" : "leftPartitionSymbol", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "rightPartitionSymbol", + "javaName" : "rightPartitionSymbol", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "kdbTree", + "javaName" : "kdbTree", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "opaque", + "name" : "io.airlift.slice.Slice" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticAggregations", + "simpleName" : "StatisticAggregations", + "kind" : "class", + "properties" : [ { + "jsonName" : "aggregations", + "javaName" : "aggregations", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.AggregationNode$Aggregation" + } + } + }, { + "jsonName" : "groupingSymbols", + "javaName" : "groupingSymbols", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor", + "simpleName" : "StatisticAggregationsDescriptor", + "kind" : "class", + "properties" : [ { + "jsonName" : "grouping", + "javaName" : "grouping", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "primitive", + "name" : "java.lang.String" + }, + "valueType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + }, { + "jsonName" : "tableStatistics", + "javaName" : "tableStatistics", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "enum", + "name" : "io.trino.spi.statistics.TableStatisticType", + "enumValues" : [ "ROW_COUNT" ] + }, + "valueType" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } + }, { + "jsonName" : "columnStatisticsList", + "javaName" : "columnStatisticsList", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor$ColumnStatisticAggregationsDescriptor" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor$ColumnStatisticAggregationsDescriptor", + "simpleName" : "ColumnStatisticAggregationsDescriptor", + "kind" : "record", + "properties" : [ { + "jsonName" : "metadata", + "javaName" : "metadata", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.statistics.ColumnStatisticMetadata" + } + }, { + "jsonName" : "input", + "javaName" : "input", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "java.lang.Object" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticsWriterNode", + "simpleName" : "StatisticsWriterNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "target", + "javaName" : "target", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.StatisticsWriterNode$WriteStatisticsTarget" + } + }, { + "jsonName" : "rowCountSymbol", + "javaName" : "rowCountSymbol", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "rowCountEnabled", + "javaName" : "rowCountEnabled", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "descriptor", + "javaName" : "descriptor", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.StatisticsWriterNode$WriteStatisticsHandle", + "simpleName" : "WriteStatisticsHandle", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.AnalyzeTableHandle" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableFinishNode", + "simpleName" : "TableFinishNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "target", + "javaName" : "target", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.TableWriterNode$WriterTarget" + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "statisticsAggregation", + "javaName" : "statisticsAggregation", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregations" + } + } + }, { + "jsonName" : "statisticsAggregationDescriptor", + "javaName" : "statisticsAggregationDescriptor", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableScanNode", + "simpleName" : "TableScanNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "table", + "javaName" : "table", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "assignments", + "javaName" : "assignments", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "opaque", + "name" : "io.trino.spi.connector.ColumnHandle" + } + } + }, { + "jsonName" : "updateTarget", + "javaName" : "updateTarget", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "useConnectorNodePartitioning", + "javaName" : "useConnectorNodePartitioning", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Boolean" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode", + "simpleName" : "TableWriterNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "target", + "javaName" : "target", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.TableWriterNode$WriterTarget" + } + }, { + "jsonName" : "rowCountSymbol", + "javaName" : "rowCountSymbol", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "fragmentSymbol", + "javaName" : "fragmentSymbol", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "columns", + "javaName" : "columns", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "columnNames", + "javaName" : "columnNames", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "partitioningScheme", + "javaName" : "partitioningScheme", + "creatorIndex" : 7, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.PartitioningScheme" + } + } + }, { + "jsonName" : "statisticsAggregation", + "javaName" : "statisticsAggregation", + "creatorIndex" : 8, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregations" + } + } + }, { + "jsonName" : "statisticsAggregationDescriptor", + "javaName" : "statisticsAggregationDescriptor", + "creatorIndex" : 9, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.StatisticAggregationsDescriptor" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode$CreateTarget", + "simpleName" : "CreateTarget", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.OutputTableHandle" + } + }, { + "jsonName" : "schemaTableName", + "javaName" : "schemaTableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.SchemaTableName" + } + }, { + "jsonName" : "multipleWritersPerPartitionSupported", + "javaName" : "multipleWritersPerPartitionSupported", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "maxWriterTasks", + "javaName" : "maxWriterTasks", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "writerScalingOptions", + "javaName" : "writerScalingOptions", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.WriterScalingOptions" + } + }, { + "jsonName" : "replace", + "javaName" : "replace", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode$InsertTarget", + "simpleName" : "InsertTarget", + "kind" : "class", + "properties" : [ { + "jsonName" : "handle", + "javaName" : "handle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.InsertTableHandle" + } + }, { + "jsonName" : "schemaTableName", + "javaName" : "schemaTableName", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.SchemaTableName" + } + }, { + "jsonName" : "multipleWritersPerPartitionSupported", + "javaName" : "multipleWritersPerPartitionSupported", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "maxWriterTasks", + "javaName" : "maxWriterTasks", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.Integer" + } + } + }, { + "jsonName" : "writerScalingOptions", + "javaName" : "writerScalingOptions", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.WriterScalingOptions" + } + }, { + "jsonName" : "sourceTableHandles", + "javaName" : "sourceTableHandles", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TableWriterNode$RefreshMaterializedViewTarget", + "simpleName" : "RefreshMaterializedViewTarget", + "kind" : "class", + "properties" : [ { + "jsonName" : "tableHandle", + "javaName" : "tableHandle", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + }, { + "jsonName" : "insertHandle", + "javaName" : "insertHandle", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.InsertTableHandle" + } + }, { + "jsonName" : "schemaTableName", + "javaName" : "schemaTableName", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.SchemaTableName" + } + }, { + "jsonName" : "sourceTableHandles", + "javaName" : "sourceTableHandles", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.metadata.TableHandle" + } + } + }, { + "jsonName" : "sourceTableFunctions", + "javaName" : "sourceTableFunctions", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "hasNonDeterministicFunctions", + "javaName" : "hasNonDeterministicFunctions", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "writerScalingOptions", + "javaName" : "writerScalingOptions", + "creatorIndex" : 6, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.spi.connector.WriterScalingOptions" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.TopNNode", + "simpleName" : "TopNNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "count", + "javaName" : "count", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "long" + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + }, { + "jsonName" : "step", + "javaName" : "step", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.TopNNode$Step", + "enumValues" : [ "SINGLE", "PARTIAL", "FINAL" ] + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.UnionNode", + "simpleName" : "UnionNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "sources", + "javaName" : "sources", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + } + }, { + "jsonName" : "outputToInputs", + "javaName" : "outputToInputs", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "com.google.common.collect.ListMultimap" + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.UnnestNode", + "simpleName" : "UnnestNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "replicateSymbols", + "javaName" : "replicateSymbols", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "mappings", + "javaName" : "mappings", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.UnnestNode$Mapping" + } + } + }, { + "jsonName" : "ordinalitySymbol", + "javaName" : "ordinalitySymbol", + "creatorIndex" : 4, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "joinType", + "javaName" : "joinType", + "creatorIndex" : 5, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.JoinType", + "enumValues" : [ "INNER", "LEFT", "RIGHT", "FULL" ] + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.UnnestNode$Mapping", + "simpleName" : "Mapping", + "kind" : "class", + "properties" : [ { + "jsonName" : "input", + "javaName" : "input", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + }, { + "jsonName" : "outputs", + "javaName" : "outputs", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.ValuesNode", + "simpleName" : "ValuesNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "outputSymbols", + "javaName" : "outputSymbols", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "rowCount", + "javaName" : "rowCount", + "creatorIndex" : 2, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "rows", + "javaName" : "rows", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.WindowNode", + "simpleName" : "WindowNode", + "kind" : "class", + "properties" : [ { + "jsonName" : "id", + "javaName" : "id", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.sql.planner.plan.PlanNodeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + }, { + "jsonName" : "source", + "javaName" : "source", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.planner.plan.PlanNode" + } + }, { + "jsonName" : "specification", + "javaName" : "specification", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.DataOrganizationSpecification" + } + }, { + "jsonName" : "windowFunctions", + "javaName" : "windowFunctions", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "map", + "keyType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + }, + "valueType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.WindowNode$Function" + } + } + }, { + "jsonName" : "prePartitionedInputs", + "javaName" : "prePartitionedInputs", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "set", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "preSortedOrderPrefix", + "javaName" : "preSortedOrderPrefix", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.WindowNode$Frame", + "simpleName" : "Frame", + "kind" : "class", + "properties" : [ { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.WindowFrameType", + "enumValues" : [ "RANGE", "ROWS", "GROUPS" ] + } + }, { + "jsonName" : "startType", + "javaName" : "startType", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.FrameBoundType", + "enumValues" : [ "UNBOUNDED_PRECEDING", "PRECEDING", "CURRENT_ROW", "FOLLOWING", "UNBOUNDED_FOLLOWING" ] + } + }, { + "jsonName" : "startValue", + "javaName" : "startValue", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "sortKeyCoercedForFrameStartComparison", + "javaName" : "sortKeyCoercedForFrameStartComparison", + "creatorIndex" : 3, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "endType", + "javaName" : "endType", + "creatorIndex" : 4, + "nullability" : "unknown", + "type" : { + "kind" : "enum", + "name" : "io.trino.sql.planner.plan.FrameBoundType", + "enumValues" : [ "UNBOUNDED_PRECEDING", "PRECEDING", "CURRENT_ROW", "FOLLOWING", "UNBOUNDED_FOLLOWING" ] + } + }, { + "jsonName" : "endValue", + "javaName" : "endValue", + "creatorIndex" : 5, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + }, { + "jsonName" : "sortKeyCoercedForFrameEndComparison", + "javaName" : "sortKeyCoercedForFrameEndComparison", + "creatorIndex" : 6, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.Symbol" + } + } + } ] + }, { + "javaName" : "io.trino.sql.planner.plan.WindowNode$Function", + "simpleName" : "Function", + "kind" : "class", + "properties" : [ { + "jsonName" : "resolvedFunction", + "javaName" : "resolvedFunction", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.metadata.ResolvedFunction" + } + }, { + "jsonName" : "arguments", + "javaName" : "arguments", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + } + }, { + "jsonName" : "orderingScheme", + "javaName" : "orderingScheme", + "creatorIndex" : 2, + "nullability" : "nullable", + "type" : { + "kind" : "optional", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.planner.OrderingScheme" + } + } + }, { + "jsonName" : "frame", + "javaName" : "frame", + "creatorIndex" : 3, + "nullability" : "unknown", + "type" : { + "kind" : "model", + "name" : "io.trino.sql.planner.plan.WindowNode$Frame" + } + }, { + "jsonName" : "ignoreNulls", + "javaName" : "ignoreNulls", + "creatorIndex" : 4, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + }, { + "jsonName" : "distinct", + "javaName" : "distinct", + "creatorIndex" : 5, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "boolean" + } + } ] + }, { + "javaName" : "io.trino.sql.routine.ir.IrRoutine", + "simpleName" : "IrRoutine", + "kind" : "record", + "properties" : [ { + "jsonName" : "returnType", + "javaName" : "returnType", + "creatorIndex" : 0, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "parameters", + "javaName" : "parameters", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "list", + "elementType" : { + "kind" : "model", + "name" : "io.trino.sql.routine.ir.IrVariable" + } + } + }, { + "jsonName" : "body", + "javaName" : "body", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.routine.ir.IrStatement" + } + } ] + }, { + "javaName" : "io.trino.sql.routine.ir.IrVariable", + "simpleName" : "IrVariable", + "kind" : "record", + "properties" : [ { + "jsonName" : "field", + "javaName" : "field", + "creatorIndex" : 0, + "nullability" : "non_null", + "type" : { + "kind" : "primitive", + "name" : "int" + } + }, { + "jsonName" : "type", + "javaName" : "type", + "creatorIndex" : 1, + "nullability" : "unknown", + "type" : { + "kind" : "value", + "name" : "io.trino.spi.type.Type", + "elementType" : { + "kind" : "value", + "name" : "io.trino.spi.type.TypeId", + "elementType" : { + "kind" : "primitive", + "name" : "java.lang.String" + } + } + } + }, { + "jsonName" : "defaultValue", + "javaName" : "defaultValue", + "creatorIndex" : 2, + "nullability" : "unknown", + "type" : { + "kind" : "opaque", + "name" : "io.trino.sql.ir.Expression" + } + } ] + } ] +} \ No newline at end of file