QueryExecutionErrors (Spark 3.5.3 JavaDoc)

Object
- org.apache.spark.sql.errors.QueryExecutionErrors

```
public class QueryExecutionErrors
extends Object
```
Object for grouping error messages from (most) exceptions thrown during query execution. This does not include exceptions thrown during the eager execution of commands, which are grouped into QueryCompilationErrors.

Constructor Summary

Constructors
Constructor and Description

QueryExecutionErrors()

Constructors
Constructor and Description
`QueryExecutionErrors()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static org.apache.spark.SparkUnsupportedOperationException`	`addFilesWithAbsolutePathUnsupportedError(String commitProtocol)`
`static Throwable`	`addNewFunctionMismatchedWithFunctionError(String funcName)`
`static RuntimeException`	`aesCryptoError(String detailMessage)`
`static RuntimeException`	`aesModeUnsupportedError(String mode, String padding)`
`static RuntimeException`	`aesUnsupportedAad(String mode)`
`static RuntimeException`	`aesUnsupportedIv(String mode)`
`static org.apache.spark.SparkUnsupportedOperationException`	`alterTableWithDropPartitionAndPurgeUnsupportedError()`
`static org.apache.spark.SparkDateTimeException`	`ansiDateTimeError(Exception e)`
`static org.apache.spark.SparkDateTimeException`	`ansiDateTimeParseError(Exception e)`
`static IllegalArgumentException`	`ansiIllegalArgumentError(IllegalArgumentException e)`
`static org.apache.spark.SparkIllegalArgumentException`	`ansiIllegalArgumentError(String message)`
`static org.apache.spark.SparkArithmeticException`	`arithmeticOverflowError(ArithmeticException e)`
`static String`	`arithmeticOverflowError$default$2()`
`static org.apache.spark.sql.catalyst.trees.SQLQueryContext`	`arithmeticOverflowError$default$3()`
`static org.apache.spark.SparkUnsupportedOperationException`	`attributesForTypeUnsupportedError(org.apache.spark.sql.catalyst.ScalaReflection.Schema schema)`
`static org.apache.spark.SparkFileNotFoundException`	`batchMetadataFileNotFoundError(org.apache.hadoop.fs.Path batchMetadataFile)`
`static org.apache.spark.SparkArithmeticException`	`binaryArithmeticCauseOverflowError(short eval1, String symbol, short eval2)`
`static org.apache.spark.SparkUnsupportedOperationException`	`buildReaderUnsupportedForFileFormatError(String format)`
`static Throwable`	`cannotAcquireMemoryToBuildLongHashedRelationError(long size, long got)`
`static Throwable`	`cannotAcquireMemoryToBuildUnsafeHashedRelationError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotAddMultiPartitionsOnNonatomicPartitionTableError(String tableName)`
`static Throwable`	`cannotAllocateMemoryToGrowBytesToBytesMapError()`
`static Throwable`	`cannotBroadcastTableOverMaxTableBytesError(long maxBroadcastTableBytes, long dataSize)`
`static Throwable`	`cannotBroadcastTableOverMaxTableRowsError(long maxBroadcastTableRows, long numRows)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotBuildHashedRelationLargerThan8GError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotBuildHashedRelationWithUniqueKeysExceededError()`
`static Throwable`	`cannotCastError(DataType from, DataType to)`
`static Throwable`	`cannotCastFromNullTypeError(DataType to)`
`static ArithmeticException`	`cannotChangeDecimalPrecisionError(Decimal value, int decimalPrecision, int decimalScale, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static Throwable`	`cannotClearOutputDirectoryError(org.apache.hadoop.fs.Path staticPrefixPath)`
`static Throwable`	`cannotClearPartitionDirectoryError(org.apache.hadoop.fs.Path path)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotCloneOrCopyReadOnlySQLConfError()`
`static org.apache.spark.SparkIllegalArgumentException`	`cannotCompareCostWithTargetCostError(String cost)`
`static Throwable`	`cannotConvertCatalystValueToProtobufEnumTypeError(scala.collection.Seq<String> sqlColumn, String protobufColumn, String data, String enumString)`
`static Throwable`	`cannotConvertOrcTimestampNTZToTimestampLTZError()`
`static Throwable`	`cannotConvertOrcTimestampToTimestampNTZError()`
`static org.apache.spark.SparkRuntimeException`	`cannotCreateArrayWithElementsExceedLimitError(long numElements, String additionalErrorMessage)`
`static Throwable`	`cannotCreateColumnarReaderError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotCreateJDBCTableWithPartitionsError()`
`static org.apache.spark.SparkRuntimeException`	`cannotCreateParquetConverterForDataTypeError(DataType t, String parquetType)`
`static org.apache.spark.SparkRuntimeException`	`cannotCreateParquetConverterForDecimalTypeError(DecimalType t, String parquetType)`
`static org.apache.spark.SparkRuntimeException`	`cannotCreateParquetConverterForTypeError(DecimalType t, String parquetType)`
`static org.apache.spark.SparkRuntimeException`	`cannotCreateStagingDirError(String message, java.io.IOException e)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotDropMultiPartitionsOnNonatomicPartitionTableError(String tableName)`
`static Throwable`	`cannotEvaluateExpressionError(org.apache.spark.sql.catalyst.expressions.Expression expression)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotExecuteStreamingRelationExecError()`
`static Throwable`	`cannotFetchTablesOfDatabaseError(String dbName, Exception e)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotFindConstructorForTypeError(String tpe)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotFindEncoderForTypeError(String typeName)`
`static Throwable`	`cannotGenerateCodeForExpressionError(org.apache.spark.sql.catalyst.expressions.Expression expression)`
`static org.apache.spark.SparkIllegalArgumentException`	`cannotGenerateCodeForIncomparableTypeError(String codeType, DataType dataType)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotGetEventTimeWatermarkError()`
`static org.apache.spark.SparkIllegalArgumentException`	`cannotGetJdbcTypeError(DataType dt)`
`static org.apache.spark.SparkRuntimeException`	`cannotGetOuterPointerForInnerClassError(Class<?> innerCls)`
`static org.apache.spark.SparkRuntimeException`	`cannotGetSQLConfInSchedulerEventLoopThreadError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotHaveCircularReferencesInBeanClassError(Class<?> clazz)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotHaveCircularReferencesInClassError(String t)`
`static Throwable`	`cannotInstantiateAbstractCatalogPluginClassError(String name, String pluginClassName, Exception e)`
`static org.apache.spark.SparkIllegalArgumentException`	`cannotInterpolateClassIntoCodeBlockError(Object arg)`
`static Throwable`	`cannotLoadUserDefinedTypeError(String name, String userClass)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotMergeClassWithOtherClassError(String className, String otherClass)`
`static Throwable`	`cannotMergeDecimalTypesWithIncompatibleScaleError(int leftScale, int rightScale)`
`static Throwable`	`cannotMergeIncompatibleDataTypesError(DataType left, DataType right)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotMutateReadOnlySQLConfError()`
`static Throwable`	`cannotParseDecimalError()`
`static org.apache.spark.SparkRuntimeException`	`cannotParseJsonArraysAsStructsError(String recordStr)`
`static org.apache.spark.SparkRuntimeException`	`cannotParseJSONFieldError(com.fasterxml.jackson.core.JsonParser parser, com.fasterxml.jackson.core.JsonToken jsonType, DataType dataType)`
`static org.apache.spark.SparkRuntimeException`	`cannotParseJSONFieldError(String fieldName, String fieldValue, com.fasterxml.jackson.core.JsonToken jsonType, DataType dataType)`
`static org.apache.spark.SparkIllegalArgumentException`	`cannotParseStatisticAsPercentileError(String stats, NumberFormatException e)`
`static org.apache.spark.SparkRuntimeException`	`cannotParseStringAsDataTypeError(com.fasterxml.jackson.core.JsonParser parser, com.fasterxml.jackson.core.JsonToken token, DataType dataType)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotPurgeAsBreakInternalStateError()`
`static Throwable`	`cannotReadFilesError(Throwable e, String path)`
`static Throwable`	`cannotReadFooterForFileError(org.apache.hadoop.fs.Path file, Exception e)`
`static Throwable`	`cannotRecognizeHiveTypeError(org.apache.spark.sql.catalyst.parser.ParseException e, String fieldType, String fieldName)`
`static org.apache.spark.SparkRuntimeException`	`cannotRemovePartitionDirError(org.apache.hadoop.fs.Path partitionPath)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotRemoveReservedPropertyError(String property)`
`static Throwable`	`cannotRestorePermissionsForPathError(org.apache.hadoop.fs.permission.FsPermission permission, org.apache.hadoop.fs.Path path)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotSafelyMergeSerdePropertiesError(scala.collection.immutable.Map<String,String> props1, scala.collection.immutable.Map<String,String> props2, scala.collection.immutable.Set<String> conflictKeys)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotSetTimeoutDurationError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotSetTimeoutTimestampError()`
`static org.apache.spark.SparkIllegalArgumentException`	`cannotSpecifyBothJdbcTableNameAndQueryError(String jdbcTableName, String jdbcQueryString)`
`static Throwable`	`cannotTerminateGeneratorError(org.apache.spark.sql.catalyst.analysis.UnresolvedGenerator generator)`
`static org.apache.spark.SparkIllegalArgumentException`	`cannotTranslateNonNullValueForFieldError(int pos)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cannotUseInvalidJavaIdentifierAsFieldNameError(String fieldName, org.apache.spark.sql.catalyst.WalkedTypePath walkedTypePath)`
`static ArithmeticException`	`castingCauseOverflowError(Object t, DataType from, DataType to)`
`static ArithmeticException`	`castingCauseOverflowErrorInTableInsert(DataType from, DataType to, String columnName)`
`static Throwable`	`catalogFailToCallPublicNoArgConstructorError(String name, String pluginClassName, Exception e)`
`static Throwable`	`catalogFailToFindPublicNoArgConstructorError(String name, String pluginClassName, Exception e)`
`static Throwable`	`catalogPluginClassNotFoundError(String name)`
`static Throwable`	`catalogPluginClassNotFoundForCatalogError(String name, String pluginClassName, Exception e)`
`static Throwable`	`catalogPluginClassNotImplementedError(String name, String pluginClassName)`
`static org.apache.spark.SparkRuntimeException`	`classHasUnexpectedSerializerError(String clsName, org.apache.spark.sql.catalyst.expressions.Expression objSerializer)`
`static org.apache.spark.SparkRuntimeException`	`classUnsupportedByMapObjectsError(Class<?> cls)`
`static org.apache.spark.SparkUnsupportedOperationException`	`cleanUpSourceFilesUnsupportedError()`
`static org.apache.spark.SparkSQLFeatureNotSupportedException`	`commentOnTableUnsupportedError()`
`static Throwable`	`commitDeniedError(int partId, long taskId, int attemptId, int stageId, int stageAttempt)`
`static Throwable`	`comparatorReturnsNull(String firstValue, String secondValue)`
`static Throwable`	`compilerError(org.codehaus.commons.compiler.CompileException e)`
`static org.apache.spark.SparkRuntimeException`	`concatArraysWithElementsExceedLimitError(long numberOfElements)`
`static org.apache.spark.SparkConcurrentModificationException`	`concurrentModificationOnExternalAppendOnlyUnsafeRowArrayError(String className)`
`static Throwable`	`concurrentQueryInstanceError()`
`static Throwable`	`concurrentStreamLogUpdate(long batchId)`
`static org.apache.spark.SparkRuntimeException`	`constructorNotFoundError(String cls)`
`static org.apache.spark.SparkUnsupportedOperationException`	`continuousProcessingUnsupportedByDataSourceError(String sourceName)`
`static Throwable`	`convertHiveTableToCatalogTableError(SparkException e, String dbName, String tableName)`
`static org.apache.spark.SparkRuntimeException`	`createArrayWithElementsExceedLimitError(Object count)`
`static org.apache.spark.SparkIllegalArgumentException`	`createStreamingSourceNotSpecifySchemaError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`customCollectionClsNotResolvedError()`
`static Throwable`	`databaseNameConflictWithSystemPreservedDatabaseError(String globalTempDB)`
`static org.apache.spark.SparkIllegalArgumentException`	`dataPathNotSpecifiedError()`
`static org.apache.spark.SparkClassNotFoundException`	`dataSourceNotFoundError(String provider, Throwable error)`
`static org.apache.spark.SparkUnsupportedOperationException`	`dataTypeUnexpectedError(DataType dataType)`
`static Throwable`	`dataTypeUnsupportedError(String dataType, String failure)`
`static org.apache.spark.SparkUnsupportedOperationException`	`dataTypeUnsupportedYetError(DataType dataType)`
`static org.apache.spark.SparkUnsupportedOperationException`	`ddlUnsupportedTemporarilyError(String ddl)`
`static org.apache.spark.SparkArithmeticException`	`decimalPrecisionExceedsMaxPrecisionError(int precision, int maxPrecision)`
`static org.apache.spark.SparkUnsupportedOperationException`	`decorrelateInnerQueryThroughPlanUnsupportedError(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan)`
`static Throwable`	`defaultDatabaseNotExistsError(String defaultDatabase)`
`static ArithmeticException`	`divideByZeroError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkUnsupportedOperationException`	`doExecuteBroadcastNotImplementedError(String nodeName)`
`static org.apache.spark.SparkUnsupportedOperationException`	`dropTableWithPurgeUnsupportedError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`duplicatedFieldNameInArrowStructError(scala.collection.Seq<String> fieldNames)`
`static org.apache.spark.SparkRuntimeException`	`duplicateMapKeyFoundError(Object key)`
`static Throwable`	`dynamicPartitionKeyNotAmongWrittenPartitionPathsError(String key)`
`static Throwable`	`dynamicPartitionOverwriteUnsupportedByTableError(Table table)`
`static org.apache.spark.SparkUnsupportedOperationException`	`elementsOfTupleExceedLimitError()`
`static org.apache.spark.SparkRuntimeException`	`emptyJsonFieldValueError(DataType dataType)`
`static org.apache.spark.SparkIllegalArgumentException`	`emptyOptionError(String optionName)`
`static Throwable`	`endOfIteratorError()`
`static Throwable`	`endOfStreamError()`
`static org.apache.spark.SparkRuntimeException`	`exceedMapSizeLimitError(int size)`
`static org.apache.spark.SparkRuntimeException`	`exceedMaxLimit(int limit)`
`static Throwable`	`executeBroadcastTimeoutError(long timeout, scala.Option<java.util.concurrent.TimeoutException> ex)`
`static org.apache.spark.SparkUnsupportedOperationException`	`executeCodePathUnsupportedError(String execName)`
`static org.apache.spark.SparkRuntimeException`	`expressionDecodingError(Exception e, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> expressions)`
`static org.apache.spark.SparkRuntimeException`	`expressionEncodingError(Exception e, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> expressions)`
`static Throwable`	`failedExecuteUserDefinedFunctionError(String functionName, String inputTypes, String outputType, Throwable e)`
`static Throwable`	`failedMergingSchemaError(StructType leftSchema, StructType rightSchema, SparkException e)`
`static org.apache.spark.SparkRuntimeException`	`failedParsingStructTypeError(String raw)`
`static Throwable`	`failedRenameTempFileError(org.apache.hadoop.fs.Path srcPath, org.apache.hadoop.fs.Path dstPath)`
`static org.apache.spark.SparkRuntimeException`	`failedToCastValueToDataTypeForPartitionColumnError(String value, DataType dataType, String columnName)`
`static String`	`failedToCompileMsg(Exception e)`
`static SparkException`	`failedToExecuteQueryError(Throwable e)`
`static Throwable`	`failedToGenerateEpochMarkerError(Throwable failureReason)`
`static Throwable`	`failedToInstantiateConstructorForCatalogError(String name, String pluginClassName, Exception e)`
`static Throwable`	`failedToMergeIncompatibleSchemasError(StructType left, StructType right, Throwable e)`
`static Throwable`	`failedToPushRowIntoRowQueueError(String rowQueue)`
`static Throwable`	`failedToReadDataError(Throwable failureReason)`
`static Throwable`	`failedToReadDeltaFileError(org.apache.hadoop.fs.Path fileToRead, String clazz, int keySize)`
`static Throwable`	`failedToReadSnapshotFileError(org.apache.hadoop.fs.Path fileToRead, String clazz, String message)`
`static org.apache.spark.SparkRuntimeException`	`failToConvertValueToJsonError(Object value, Class<?> cls, DataType dataType)`
`static org.apache.spark.SparkUpgradeException`	`failToParseDateTimeInNewParserError(String s, Throwable e)`
`static org.apache.spark.SparkUpgradeException`	`failToRecognizePatternAfterUpgradeError(String pattern, Throwable e)`
`static org.apache.spark.SparkRuntimeException`	`failToRecognizePatternError(String pattern, Throwable e)`
`static org.apache.spark.SparkSecurityException`	`failToSetOriginalACLBackError(String aclEntries, org.apache.hadoop.fs.Path path, Throwable e)`
`static org.apache.spark.SparkIllegalArgumentException`	`fallbackV1RelationReportsInconsistentSchemaError(StructType v2Schema, StructType v1Schema)`
`static org.apache.spark.SparkRuntimeException`	`fieldCannotBeNullError(int index, String fieldName)`
`static String`	`fieldCannotBeNullMsg(int index, String fieldName)`
`static org.apache.spark.SparkDateTimeException`	`fieldDiffersFromDerivedLocalDateError(java.time.temporal.ChronoField field, int actual, int expected, java.time.LocalDate candidate)`
`static org.apache.spark.SparkUnsupportedOperationException`	`fieldIndexOnRowWithoutSchemaError()`
`static Throwable`	`fileLengthExceedsMaxLengthError(org.apache.hadoop.fs.FileStatus status, int maxLength)`
`static org.apache.spark.SparkFileNotFoundException`	`fileNotFoundError(java.io.FileNotFoundException e)`
`static org.apache.spark.SparkRuntimeException`	`flattenArraysWithElementsExceedLimitError(long numberOfElements)`
`static Throwable`	`foreachWriterAbortedDueToTaskFailureError()`
`static org.apache.spark.SparkRuntimeException`	`foundDuplicateFieldInCaseInsensitiveModeError(String requiredFieldName, String matchedOrcFields)`
`static org.apache.spark.SparkRuntimeException`	`foundDuplicateFieldInFieldIdLookupModeError(int requiredId, String matchedFields)`
`static org.apache.spark.SparkRuntimeException`	`foundNullValueForNotNullableFieldError(String name)`
`static org.apache.spark.SparkSQLFeatureNotSupportedException`	`getParentLoggerNotImplementedError(String className)`
`static org.apache.spark.SparkRuntimeException`	`getPartitionMetadataByFilterError(java.lang.reflect.InvocationTargetException e)`
`static QueryContext[]`	`getQueryContext(org.apache.spark.sql.catalyst.trees.SQLQueryContext sqlContext)`
`static String`	`getSummary(org.apache.spark.sql.catalyst.trees.SQLQueryContext sqlContext)`
`static org.apache.spark.SparkUnsupportedOperationException`	`getTablesByTypeUnsupportedByHiveVersionError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`hiveTableWithAnsiIntervalsError(org.apache.spark.sql.catalyst.TableIdentifier table)`
`static Throwable`	`hllInvalidInputSketchBuffer(String function)`
`static Throwable`	`hllInvalidLgK(String function, int min, int max, String value)`
`static Throwable`	`hllUnionDifferentLgK(int left, int right, String function)`
`static Throwable`	`illegalLocationClauseForViewPartitionError()`
`static Throwable`	`illegalUrlError(org.apache.spark.unsafe.types.UTF8String url, IllegalArgumentException e)`
`static Throwable`	`incompatibleDataSourceRegisterError(Throwable e)`
`static Throwable`	`incorrectEndOffset(long rowsPerSecond, long maxSeconds, long endSeconds)`
`static Throwable`	`incorrectRampUpRate(long rowsPerSecond, long maxSeconds, long rampUpTimeSeconds)`
`static org.apache.spark.SparkUnsupportedOperationException`	`inferSchemaUnsupportedForHiveError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`initialTypeNotTargetDataTypeError(DataType dataType, String target)`
`static org.apache.spark.SparkUnsupportedOperationException`	`initialTypeNotTargetDataTypesError(DataType dataType)`
`static org.apache.spark.SparkRuntimeException`	`inputExternalRowCannotBeNullError()`
`static Throwable`	`inputFilterNotFullyConvertibleError(String owner)`
`static Throwable`	`internalCompilerError(org.codehaus.commons.compiler.InternalCompilerException e)`
`static ArithmeticException`	`intervalArithmeticOverflowError(String message, String hint, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static ArithmeticException`	`intervalDividedByZeroError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static RuntimeException`	`invalidAesIvLengthError(String mode, int actualLength)`
`static RuntimeException`	`invalidAesKeyLengthError(int actualLength)`
`static ArrayIndexOutOfBoundsException`	`invalidArrayIndexError(int index, int numElements, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static ArrayIndexOutOfBoundsException`	`invalidBitmapPositionError(long bitPosition, long bitmapNumBytes)`
`static Throwable`	`invalidBucketFile(String path)`
`static Throwable`	`invalidCatalogNameError(String name)`
`static ArrayIndexOutOfBoundsException`	`invalidElementAtIndexError(int index, int numElements, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkIllegalArgumentException`	`invalidEmptyLocationError(String location)`
`static java.time.DateTimeException`	`invalidFractionOfSecondError()`
`static RuntimeException`	`invalidIndexOfZeroError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkDateTimeException`	`invalidInputInCastToDatetimeError(double value, DataType to, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkDateTimeException`	`invalidInputInCastToDatetimeError(org.apache.spark.unsafe.types.UTF8String value, DataType to, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkNumberFormatException`	`invalidInputInCastToNumberError(DataType to, org.apache.spark.unsafe.types.UTF8String s, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkIllegalArgumentException`	`invalidInputInConversionError(DataType to, org.apache.spark.unsafe.types.UTF8String s, org.apache.spark.unsafe.types.UTF8String fmt, String hint)`
`static org.apache.spark.SparkRuntimeException`	`invalidInputSyntaxForBooleanError(org.apache.spark.unsafe.types.UTF8String s, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkIllegalArgumentException`	`invalidJdbcNumPartitionsError(int n, String jdbcNumPartitions)`
`static org.apache.spark.SparkIllegalArgumentException`	`invalidJdbcTxnIsolationLevelError(String jdbcTxnIsolationLevel, String value)`
`static Throwable`	`invalidKerberosConfigForHiveServer2Error()`
`static org.apache.spark.SparkIllegalArgumentException`	`invalidNamespaceNameError(String[] namespace)`
`static org.apache.spark.SparkIllegalArgumentException`	`invalidNumberFormatError(DataType dataType, String input, String format)`
`static org.apache.spark.SparkUnsupportedOperationException`	`invalidPartitionFilterError()`
`static RuntimeException`	`invalidPatternError(String funcName, String pattern, Throwable cause)`
`static RuntimeException`	`invalidRegexGroupIndexError(String funcName, int groupCount, int groupIndex)`
`static org.apache.spark.SparkArrayIndexOutOfBoundsException`	`invalidStartIndexError(int numRows, int startIndex)`
`static org.apache.spark.SparkUnsupportedOperationException`	`invalidStreamingOutputModeError(scala.Option<OutputMode> outputMode)`
`static org.apache.spark.SparkIllegalArgumentException`	`invalidUrlError(org.apache.spark.unsafe.types.UTF8String url, java.net.URISyntaxException e)`
`static org.apache.spark.SparkUnsupportedOperationException`	`latestOffsetNotCalledError()`
`static Throwable`	`legacyCheckpointDirectoryExistsError(org.apache.hadoop.fs.Path checkpointPath, String legacyCheckpointDir)`
`static Throwable`	`legacyMetadataPathExistsError(org.apache.hadoop.fs.Path metadataPath, org.apache.hadoop.fs.Path legacyMetadataPath)`
`static RuntimeException`	`literalTypeUnsupportedError(Object v)`
`static org.apache.spark.SparkClassNotFoundException`	`loadHiveClientCausesNoClassDefFoundError(NoClassDefFoundError cnf, scala.collection.Seq<java.net.URL> execJars, String key, java.lang.reflect.InvocationTargetException e)`
`static Throwable`	`locationAlreadyExists(org.apache.spark.sql.catalyst.TableIdentifier tableId, org.apache.hadoop.fs.Path location)`
`static org.apache.spark.SparkRuntimeException`	`malformedCSVRecordError(String badRecord)`
`static Throwable`	`malformedJSONError()`
`static Throwable`	`malformedProtobufMessageDetectedInMessageParsingError(Throwable e)`
`static Throwable`	`malformedRecordsDetectedInRecordParsingError(String badRecord, org.apache.spark.sql.catalyst.util.BadRecordException e)`
`static Throwable`	`malformedRecordsDetectedInSchemaInferenceError(DataType dataType)`
`static Throwable`	`malformedRecordsDetectedInSchemaInferenceError(Throwable e)`
`static org.apache.spark.SparkRuntimeException`	`mapDataKeyArrayLengthDiffersFromValueArrayLengthError()`
`static org.apache.spark.SparkRuntimeException`	`mapSizeExceedArraySizeWhenZipMapError(int size)`
`static org.apache.spark.SparkRuntimeException`	`mergeCardinalityViolationError()`
`static Throwable`	`mergeUnsupportedByWindowFunctionError(String funcName)`
`static org.apache.spark.SparkRuntimeException`	`methodCalledInAnalyzerNotAllowedError()`
`static Throwable`	`methodNotDeclaredError(String name)`
`static Throwable`	`methodNotFoundError(Class<?> cls, String functionName, scala.collection.Seq<Class<?>> argClasses)`
`static org.apache.spark.SparkUnsupportedOperationException`	`methodNotImplementedError(String methodName)`
`static org.apache.spark.SparkUnsupportedOperationException`	`microBatchUnsupportedByDataSourceError(String srcName, String disabledSources, Table table)`
`static org.apache.spark.SparkIllegalArgumentException`	`missingDatabaseLocationError()`
`static org.apache.spark.SparkIllegalArgumentException`	`missingJdbcTableNameAndQueryError(String jdbcTableName, String jdbcQueryString)`
`static Throwable`	`multiActionAlterError(String tableName)`
`static Throwable`	`multiFailuresInStageMaterializationError(Throwable error)`
`static org.apache.spark.SparkIllegalArgumentException`	`multiplePathsSpecifiedError(scala.collection.Seq<String> allPaths)`
`static Throwable`	`multipleRowSubqueryError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkConcurrentModificationException`	`multiStreamingQueriesUsingPathConcurrentlyError(String path, org.apache.hadoop.fs.FileAlreadyExistsException e)`
`static org.apache.spark.SparkIllegalArgumentException`	`negativeValueUnexpectedError(org.apache.spark.sql.catalyst.expressions.Expression frequencyExpression)`
`static org.apache.spark.SparkIllegalArgumentException`	`nestedArraysUnsupportedError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`nestedFieldUnsupportedError(String colName)`
`static SparkException`	`noDefaultForDataTypeError(DataType dataType)`
`static AnalysisException`	`nonTimeWindowNotSupportedInStreamingError(scala.collection.Seq<String> windowFuncList, scala.collection.Seq<String> columnNameList, scala.collection.Seq<String> windowSpecList, org.apache.spark.sql.catalyst.trees.Origin origin)`
`static Throwable`	`noRecordsFromEmptyDataReaderError()`
`static Throwable`	`noSuchElementExceptionError()`
`static Throwable`	`notADatasourceRDDPartitionError(Partition split)`
`static Throwable`	`notEnoughMemoryToBuildAndBroadcastTableError(OutOfMemoryError oe, scala.collection.Seq<org.apache.spark.sql.catalyst.TableIdentifier> tables)`
`static org.apache.spark.SparkRuntimeException`	`notExpectedUnresolvedEncoderError(org.apache.spark.sql.catalyst.expressions.AttributeReference attr)`
`static org.apache.spark.SparkRuntimeException`	`notOverrideExpectedMethodsError(String className, String m1, String m2)`
`static org.apache.spark.SparkUnsupportedOperationException`	`notPublicClassError(String name)`
`static org.apache.spark.SparkRuntimeException`	`notSupportNonPrimitiveTypeError()`
`static Throwable`	`notSupportTypeError(DataType dataType)`
`static Throwable`	`notUserDefinedTypeError(String name, String userClass)`
`static org.apache.spark.SparkRuntimeException`	`nullAsMapKeyNotAllowedError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`nullLiteralsCannotBeCastedError(String name)`
`static <TreeType extends org.apache.spark.sql.catalyst.trees.TreeNode<?>> org.apache.spark.SparkRuntimeException`	`onceStrategyIdempotenceIsBrokenForBatchError(String batchName, TreeType plan, TreeType reOptimized)`
`static Throwable`	`onlySupportDataSourcesProvidingFileFormatError(String providingClass)`
`static org.apache.spark.SparkIllegalArgumentException`	`orderedOperationUnsupportedByDataTypeError(DataType dataType)`
`static org.apache.spark.SparkIllegalArgumentException`	`orderedOperationUnsupportedByDataTypeError(String dataType)`
`static org.apache.spark.SparkArithmeticException`	`outOfDecimalTypeRangeError(org.apache.spark.unsafe.types.UTF8String str)`
`static Throwable`	`outputDataTypeUnsupportedByNodeWithoutSerdeError(String nodeName, DataType dt)`
`static ArithmeticException`	`overflowInConvError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static ArithmeticException`	`overflowInIntegralDivideError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static ArithmeticException`	`overflowInSumOfDecimalError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static Throwable`	`overwriteTableByUnsupportedExpressionError(Table table)`
`static org.apache.spark.SparkUnsupportedOperationException`	`pairUnsupportedAtFunctionError(org.apache.spark.sql.catalyst.plans.logical.statsEstimation.ValueInterval r1, org.apache.spark.sql.catalyst.plans.logical.statsEstimation.ValueInterval r2, String function)`
`static org.apache.spark.SparkRuntimeException`	`paramExceedOneCharError(String paramName)`
`static Throwable`	`paramIsNotBooleanValueError(String paramName)`
`static org.apache.spark.SparkRuntimeException`	`paramIsNotIntegerError(String paramName, String value)`
`static Throwable`	`parentSparkUIToAttachTabNotFoundError()`
`static org.apache.spark.SparkRuntimeException`	`partitionColumnNotFoundInSchemaError(String col, StructType schema)`
`static RuntimeException`	`pivotColumnUnsupportedError(Object v, DataType dataType)`
`static Throwable`	`pivotNotAfterGroupByUnsupportedError()`
`static org.apache.spark.SparkRuntimeException`	`primaryConstructorNotFoundError(Class<?> cls)`
`static org.apache.spark.SparkUnsupportedOperationException`	`primitiveTypesNotSupportedError()`
`static org.apache.spark.SparkFileNotFoundException`	`readCurrentFileNotFoundError(java.io.FileNotFoundException e)`
`static Throwable`	`registeringStreamingQueryListenerError(Exception e)`
`static org.apache.spark.SparkRuntimeException`	`remoteOperationsUnsupportedError()`
`static org.apache.spark.SparkClassNotFoundException`	`removedClassInSpark2Error(String className, Throwable e)`
`static org.apache.spark.SparkFileAlreadyExistsException`	`renameAsExistsPathError(org.apache.hadoop.fs.Path dstPath)`
`static org.apache.spark.SparkSQLFeatureNotSupportedException`	`renameColumnUnsupportedForOlderMySQLError()`
`static Throwable`	`renamePathAsExistsPathError(org.apache.hadoop.fs.Path srcPath, org.apache.hadoop.fs.Path dstPath)`
`static Throwable`	`renameSrcPathNotFoundError(org.apache.hadoop.fs.Path srcPath)`
`static Throwable`	`repeatedPivotsUnsupportedError(String clause, String operation)`
`static Throwable`	`requestedPartitionsMismatchTablePartitionsError(org.apache.spark.sql.catalyst.catalog.CatalogTable table, scala.collection.immutable.Map<String,scala.Option<String>> partition)`
`static org.apache.spark.SparkRuntimeException`	`resolveCannotHandleNestedSchema(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan)`
`static org.apache.spark.SparkRuntimeException`	`rootConverterReturnNullError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`rowLargerThan256MUnsupportedError()`
`static Throwable`	`ruleIdNotFoundForRuleError(String ruleName)`
`static Throwable`	`saveModeUnsupportedError(Object saveMode, boolean pathExists)`
`static org.apache.spark.SparkClassNotFoundException`	`serDeInterfaceNotFoundError(NoClassDefFoundError e)`
`static org.apache.spark.SparkUpgradeException`	`sparkUpgradeInReadingDatesError(String format, String config, String option)`
`static org.apache.spark.SparkUpgradeException`	`sparkUpgradeInWritingDatesError(String format, String config)`
`static org.apache.spark.SparkNoSuchElementException`	`sqlConfigNotFoundError(String key)`
`static Throwable`	`stateNotDefinedOrAlreadyRemovedError()`
`static org.apache.spark.SparkIllegalArgumentException`	`statisticNotRecognizedError(String stats)`
`static org.apache.spark.SparkUnsupportedOperationException`	`streamedOperatorUnsupportedByDataSourceError(String className, String operator)`
`static Throwable`	`subprocessExitedError(int exitCode, org.apache.spark.util.CircularBuffer stderrBuffer, Throwable cause)`
`static Throwable`	`taskFailedWhileWritingRowsError(String path, Throwable cause)`
`static ArithmeticException`	`timestampAddOverflowError(long micros, int amount, String unit)`
`static String`	`toDSOption(String option)`
`static org.apache.spark.SparkIllegalArgumentException`	`tooManyArrayElementsError(int numElements, int elementSize)`
`static String`	`toSQLConf(String conf)`
`static String`	`toSQLConfVal(String conf)`
`static String`	`toSQLExpr(org.apache.spark.sql.catalyst.expressions.Expression e)`
`static String`	`toSQLId(scala.collection.Seq<String> parts)`
`static String`	`toSQLId(String parts)`
`static String`	`toSQLSchema(String schema)`
`static String`	`toSQLStmt(String text)`
`static String`	`toSQLType(org.apache.spark.sql.types.AbstractDataType t)`
`static String`	`toSQLType(String text)`
`static String`	`toSQLValue(double value)`
`static String`	`toSQLValue(float value)`
`static String`	`toSQLValue(int value)`
`static String`	`toSQLValue(long value)`
`static String`	`toSQLValue(Object v, DataType t)`
`static String`	`toSQLValue(short value)`
`static String`	`toSQLValue(String value)`
`static String`	`toSQLValue(org.apache.spark.unsafe.types.UTF8String value)`
`static Throwable`	`transformationsAndActionsNotInvokedByDriverError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`truncateMultiPartitionUnsupportedError(String tableName)`
`static org.apache.spark.SparkIllegalArgumentException`	`typeUnsupportedError(DataType dataType)`
`static Throwable`	`unableToCreateDatabaseAsFailedToCreateDirectoryError(org.apache.spark.sql.catalyst.catalog.CatalogDatabase dbDefinition, java.io.IOException e)`
`static Throwable`	`unableToCreatePartitionPathError(org.apache.hadoop.fs.Path partitionPath, java.io.IOException e)`
`static Throwable`	`unableToCreateTableAsFailedToCreateDirectoryError(String table, org.apache.hadoop.fs.Path defaultTableLocation, java.io.IOException e)`
`static Throwable`	`unableToDeletePartitionPathError(org.apache.hadoop.fs.Path partitionPath, java.io.IOException e)`
`static Throwable`	`unableToDropDatabaseAsFailedToDeleteDirectoryError(org.apache.spark.sql.catalyst.catalog.CatalogDatabase dbDefinition, java.io.IOException e)`
`static Throwable`	`unableToDropTableAsFailedToDeleteDirectoryError(String table, org.apache.hadoop.fs.Path dir, java.io.IOException e)`
`static Throwable`	`unableToRenamePartitionPathError(org.apache.hadoop.fs.Path oldPartPath, java.io.IOException e)`
`static Throwable`	`unableToRenameTableAsFailedToRenameDirectoryError(String oldName, String newName, org.apache.hadoop.fs.Path oldDir, java.io.IOException e)`
`static org.apache.spark.SparkArithmeticException`	`unaryMinusCauseOverflowError(int originValue)`
`static org.apache.spark.SparkIllegalArgumentException`	`unexpectedAccumulableUpdateValueError(Object o)`
`static org.apache.spark.SparkRuntimeException`	`unexpectedOperatorInCorrelatedSubquery(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan op, String pos)`
`static org.apache.spark.SparkRuntimeException`	`unexpectedValueForLengthInFunctionError(String prettyName)`
`static org.apache.spark.SparkRuntimeException`	`unexpectedValueForStartInFunctionError(String prettyName)`
`static org.apache.spark.SparkRuntimeException`	`unexpectedWindowFunctionFrameError(String frame)`
`static org.apache.spark.SparkRuntimeException`	`unionArrayWithElementsExceedLimitError(int length)`
`static org.apache.spark.SparkIllegalArgumentException`	`unknownColumnError(String unknownColumn)`
`static org.apache.spark.SparkRuntimeException`	`unreachableError(String err)`
`static String`	`unreachableError$default$1()`
`static org.apache.spark.SparkUnsupportedOperationException`	`unrecognizedCompressionSchemaTypeIDError(int typeId)`
`static Throwable`	`unrecognizedSqlTypeError(String jdbcTypeId, String typeName)`
`static ArithmeticException`	`unscaledValueTooLargeForPrecisionError(Decimal value, int decimalPrecision, int decimalScale, org.apache.spark.sql.catalyst.trees.SQLQueryContext context)`
`static org.apache.spark.SparkIllegalArgumentException`	`unsupportedArrayElementTypeBasedOnBinaryError(DataType dt)`
`static org.apache.spark.SparkRuntimeException`	`unsupportedArrayTypeError(Class<?> clazz)`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedArrowTypeError(org.apache.arrow.vector.types.pojo.ArrowType typeName)`
`static org.apache.spark.SparkSQLFeatureNotSupportedException`	`unsupportedCommentNamespaceError(String namespace)`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedDataTypeError(DataType typeName)`
`static org.apache.spark.SparkSQLFeatureNotSupportedException`	`unsupportedDropNamespaceError(String namespace)`
`static org.apache.spark.SparkRuntimeException`	`unsupportedEncoderError()`
`static org.apache.spark.SparkRuntimeException`	`unsupportedFieldNameError(String fieldName)`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedHiveMetastoreVersionError(String version, String key)`
`static org.apache.spark.SparkRuntimeException`	`unsupportedJavaTypeError(Class<?> clazz)`
`static org.apache.spark.SparkSQLException`	`unsupportedJdbcTypeError(String content)`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedMultipleBucketTransformsError()`
`static SparkException`	`unsupportedNaturalJoinTypeError(org.apache.spark.sql.catalyst.plans.JoinType joinType)`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedOperandTypeForSizeFunctionError(DataType dataType)`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedOperationExceptionError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedOperationForDataTypeError(DataType dataType)`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedPartitionTransformError(Transform transform)`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedPurgePartitionError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedPurgeTableError()`
`static org.apache.spark.SparkSQLFeatureNotSupportedException`	`unsupportedRemoveNamespaceCommentError(String namespace)`
`static SparkException`	`unsupportedRoundingMode(scala.Enumeration.Value roundMode)`
`static Throwable`	`unsupportedSchemaColumnConvertError(String filePath, String column, String logicalType, String physicalType, Exception e)`
`static Throwable`	`unsupportedTableChangeError(IllegalArgumentException e)`
`static Throwable`	`unsupportedTypeError(DataType dataType)`
`static org.apache.spark.SparkSQLFeatureNotSupportedException`	`unsupportedUpdateColumnNullabilityError()`
`static org.apache.spark.SparkUnsupportedOperationException`	`unsupportedUserSpecifiedSchemaError()`
`static Throwable`	`useDictionaryEncodingWhenDictionaryOverflowError()`
`static Throwable`	`userDefinedTypeNotAnnotatedAndRegisteredError(UserDefinedType<?> udt)`
`static org.apache.spark.SparkUnsupportedOperationException`	`userSpecifiedSchemaUnsupportedByDataSourceError(TableProvider provider)`
`static Throwable`	`valueIsNullError(int index)`
`static Throwable`	`writePartitionExceedConfigSizeWhenDynamicPartitionError(int numWrittenParts, int maxDynamicPartitions, String maxDynamicPartitionsKey)`
`static org.apache.spark.SparkUnsupportedOperationException`	`writeUnsupportedForBinaryFileDataSourceError()`
`static Throwable`	`writingJobFailedError(Throwable cause)`

Methods inherited from class Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- QueryExecutionErrors
```
public QueryExecutionErrors()
```

Method Detail

cannotEvaluateExpressionError

public static Throwable cannotEvaluateExpressionError(org.apache.spark.sql.catalyst.expressions.Expression expression)

cannotGenerateCodeForExpressionError

public static Throwable cannotGenerateCodeForExpressionError(org.apache.spark.sql.catalyst.expressions.Expression expression)

cannotTerminateGeneratorError

public static Throwable cannotTerminateGeneratorError(org.apache.spark.sql.catalyst.analysis.UnresolvedGenerator generator)

castingCauseOverflowError

public static ArithmeticException castingCauseOverflowError(Object t,
                                                            DataType from,
                                                            DataType to)

castingCauseOverflowErrorInTableInsert

public static ArithmeticException castingCauseOverflowErrorInTableInsert(DataType from,
                                                                         DataType to,
                                                                         String columnName)

cannotChangeDecimalPrecisionError

public static ArithmeticException cannotChangeDecimalPrecisionError(Decimal value,
                                                                    int decimalPrecision,
                                                                    int decimalScale,
                                                                    org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

invalidInputSyntaxForBooleanError

public static org.apache.spark.SparkRuntimeException invalidInputSyntaxForBooleanError(org.apache.spark.unsafe.types.UTF8String s,
                                                                                       org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

invalidInputInCastToNumberError

public static org.apache.spark.SparkNumberFormatException invalidInputInCastToNumberError(DataType to,
                                                                                          org.apache.spark.unsafe.types.UTF8String s,
                                                                                          org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

invalidInputInConversionError

public static org.apache.spark.SparkIllegalArgumentException invalidInputInConversionError(DataType to,
                                                                                           org.apache.spark.unsafe.types.UTF8String s,
                                                                                           org.apache.spark.unsafe.types.UTF8String fmt,
                                                                                           String hint)

cannotCastFromNullTypeError

public static Throwable cannotCastFromNullTypeError(DataType to)

cannotCastError

public static Throwable cannotCastError(DataType from,
                                        DataType to)

cannotParseDecimalError

public static Throwable cannotParseDecimalError()

dataTypeUnsupportedError

public static Throwable dataTypeUnsupportedError(String dataType,
                                                 String failure)

failedExecuteUserDefinedFunctionError

public static Throwable failedExecuteUserDefinedFunctionError(String functionName,
                                                              String inputTypes,
                                                              String outputType,
                                                              Throwable e)

divideByZeroError

public static ArithmeticException divideByZeroError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

intervalDividedByZeroError

public static ArithmeticException intervalDividedByZeroError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

invalidArrayIndexError

public static ArrayIndexOutOfBoundsException invalidArrayIndexError(int index,
                                                                    int numElements,
                                                                    org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

invalidElementAtIndexError

public static ArrayIndexOutOfBoundsException invalidElementAtIndexError(int index,
                                                                        int numElements,
                                                                        org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

invalidBitmapPositionError

public static ArrayIndexOutOfBoundsException invalidBitmapPositionError(long bitPosition,
                                                                        long bitmapNumBytes)

invalidFractionOfSecondError

public static java.time.DateTimeException invalidFractionOfSecondError()

ansiDateTimeParseError

public static org.apache.spark.SparkDateTimeException ansiDateTimeParseError(Exception e)

ansiDateTimeError

public static org.apache.spark.SparkDateTimeException ansiDateTimeError(Exception e)

ansiIllegalArgumentError

public static org.apache.spark.SparkIllegalArgumentException ansiIllegalArgumentError(String message)

ansiIllegalArgumentError

public static IllegalArgumentException ansiIllegalArgumentError(IllegalArgumentException e)

overflowInSumOfDecimalError

public static ArithmeticException overflowInSumOfDecimalError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

overflowInIntegralDivideError

public static ArithmeticException overflowInIntegralDivideError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

overflowInConvError

public static ArithmeticException overflowInConvError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

mapSizeExceedArraySizeWhenZipMapError

public static org.apache.spark.SparkRuntimeException mapSizeExceedArraySizeWhenZipMapError(int size)

literalTypeUnsupportedError

public static RuntimeException literalTypeUnsupportedError(Object v)

pivotColumnUnsupportedError

public static RuntimeException pivotColumnUnsupportedError(Object v,
                                                           DataType dataType)

noDefaultForDataTypeError

public static SparkException noDefaultForDataTypeError(DataType dataType)

orderedOperationUnsupportedByDataTypeError

public static org.apache.spark.SparkIllegalArgumentException orderedOperationUnsupportedByDataTypeError(DataType dataType)

orderedOperationUnsupportedByDataTypeError

public static org.apache.spark.SparkIllegalArgumentException orderedOperationUnsupportedByDataTypeError(String dataType)

invalidRegexGroupIndexError

public static RuntimeException invalidRegexGroupIndexError(String funcName,
                                                           int groupCount,
                                                           int groupIndex)

invalidUrlError

public static org.apache.spark.SparkIllegalArgumentException invalidUrlError(org.apache.spark.unsafe.types.UTF8String url,
                                                                             java.net.URISyntaxException e)

illegalUrlError

public static Throwable illegalUrlError(org.apache.spark.unsafe.types.UTF8String url,
                                        IllegalArgumentException e)

mergeUnsupportedByWindowFunctionError

public static Throwable mergeUnsupportedByWindowFunctionError(String funcName)

dataTypeUnexpectedError

public static org.apache.spark.SparkUnsupportedOperationException dataTypeUnexpectedError(DataType dataType)

typeUnsupportedError

public static org.apache.spark.SparkIllegalArgumentException typeUnsupportedError(DataType dataType)

negativeValueUnexpectedError

public static org.apache.spark.SparkIllegalArgumentException negativeValueUnexpectedError(org.apache.spark.sql.catalyst.expressions.Expression frequencyExpression)

addNewFunctionMismatchedWithFunctionError

public static Throwable addNewFunctionMismatchedWithFunctionError(String funcName)

cannotGenerateCodeForIncomparableTypeError

public static org.apache.spark.SparkIllegalArgumentException cannotGenerateCodeForIncomparableTypeError(String codeType,
                                                                                                        DataType dataType)

cannotInterpolateClassIntoCodeBlockError

public static org.apache.spark.SparkIllegalArgumentException cannotInterpolateClassIntoCodeBlockError(Object arg)

customCollectionClsNotResolvedError

public static org.apache.spark.SparkUnsupportedOperationException customCollectionClsNotResolvedError()

classUnsupportedByMapObjectsError

public static org.apache.spark.SparkRuntimeException classUnsupportedByMapObjectsError(Class<?> cls)

nullAsMapKeyNotAllowedError

public static org.apache.spark.SparkRuntimeException nullAsMapKeyNotAllowedError()

methodNotDeclaredError

public static Throwable methodNotDeclaredError(String name)

methodNotFoundError

public static Throwable methodNotFoundError(Class<?> cls,
                                            String functionName,
                                            scala.collection.Seq<Class<?>> argClasses)

constructorNotFoundError

public static org.apache.spark.SparkRuntimeException constructorNotFoundError(String cls)

unsupportedNaturalJoinTypeError

public static SparkException unsupportedNaturalJoinTypeError(org.apache.spark.sql.catalyst.plans.JoinType joinType)

notExpectedUnresolvedEncoderError

public static org.apache.spark.SparkRuntimeException notExpectedUnresolvedEncoderError(org.apache.spark.sql.catalyst.expressions.AttributeReference attr)

unsupportedEncoderError

public static org.apache.spark.SparkRuntimeException unsupportedEncoderError()

notOverrideExpectedMethodsError

public static org.apache.spark.SparkRuntimeException notOverrideExpectedMethodsError(String className,
                                                                                     String m1,
                                                                                     String m2)

failToConvertValueToJsonError

public static org.apache.spark.SparkRuntimeException failToConvertValueToJsonError(Object value,
                                                                                   Class<?> cls,
                                                                                   DataType dataType)

unexpectedOperatorInCorrelatedSubquery

public static org.apache.spark.SparkRuntimeException unexpectedOperatorInCorrelatedSubquery(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan op,
                                                                                            String pos)

unsupportedRoundingMode

public static SparkException unsupportedRoundingMode(scala.Enumeration.Value roundMode)

resolveCannotHandleNestedSchema

public static org.apache.spark.SparkRuntimeException resolveCannotHandleNestedSchema(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan)

inputExternalRowCannotBeNullError

public static org.apache.spark.SparkRuntimeException inputExternalRowCannotBeNullError()

fieldCannotBeNullMsg

public static String fieldCannotBeNullMsg(int index,
                                          String fieldName)

fieldCannotBeNullError

public static org.apache.spark.SparkRuntimeException fieldCannotBeNullError(int index,
                                                                            String fieldName)

unableToCreateDatabaseAsFailedToCreateDirectoryError

public static Throwable unableToCreateDatabaseAsFailedToCreateDirectoryError(org.apache.spark.sql.catalyst.catalog.CatalogDatabase dbDefinition,
                                                                             java.io.IOException e)

unableToDropDatabaseAsFailedToDeleteDirectoryError

public static Throwable unableToDropDatabaseAsFailedToDeleteDirectoryError(org.apache.spark.sql.catalyst.catalog.CatalogDatabase dbDefinition,
                                                                           java.io.IOException e)

unableToCreateTableAsFailedToCreateDirectoryError

public static Throwable unableToCreateTableAsFailedToCreateDirectoryError(String table,
                                                                          org.apache.hadoop.fs.Path defaultTableLocation,
                                                                          java.io.IOException e)

unableToDeletePartitionPathError

public static Throwable unableToDeletePartitionPathError(org.apache.hadoop.fs.Path partitionPath,
                                                         java.io.IOException e)

unableToDropTableAsFailedToDeleteDirectoryError

public static Throwable unableToDropTableAsFailedToDeleteDirectoryError(String table,
                                                                        org.apache.hadoop.fs.Path dir,
                                                                        java.io.IOException e)

unableToRenameTableAsFailedToRenameDirectoryError

public static Throwable unableToRenameTableAsFailedToRenameDirectoryError(String oldName,
                                                                          String newName,
                                                                          org.apache.hadoop.fs.Path oldDir,
                                                                          java.io.IOException e)

unableToCreatePartitionPathError

public static Throwable unableToCreatePartitionPathError(org.apache.hadoop.fs.Path partitionPath,
                                                         java.io.IOException e)

unableToRenamePartitionPathError

public static Throwable unableToRenamePartitionPathError(org.apache.hadoop.fs.Path oldPartPath,
                                                         java.io.IOException e)

methodNotImplementedError

public static org.apache.spark.SparkUnsupportedOperationException methodNotImplementedError(String methodName)

arithmeticOverflowError

public static org.apache.spark.SparkArithmeticException arithmeticOverflowError(ArithmeticException e)

unaryMinusCauseOverflowError

public static org.apache.spark.SparkArithmeticException unaryMinusCauseOverflowError(int originValue)

binaryArithmeticCauseOverflowError

public static org.apache.spark.SparkArithmeticException binaryArithmeticCauseOverflowError(short eval1,
                                                                                           String symbol,
                                                                                           short eval2)

intervalArithmeticOverflowError

public static ArithmeticException intervalArithmeticOverflowError(String message,
                                                                  String hint,
                                                                  org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

failedToCompileMsg

public static String failedToCompileMsg(Exception e)

internalCompilerError

public static Throwable internalCompilerError(org.codehaus.commons.compiler.InternalCompilerException e)

compilerError

public static Throwable compilerError(org.codehaus.commons.compiler.CompileException e)

unsupportedTableChangeError

public static Throwable unsupportedTableChangeError(IllegalArgumentException e)

notADatasourceRDDPartitionError

public static Throwable notADatasourceRDDPartitionError(Partition split)

dataPathNotSpecifiedError

public static org.apache.spark.SparkIllegalArgumentException dataPathNotSpecifiedError()

createStreamingSourceNotSpecifySchemaError

public static org.apache.spark.SparkIllegalArgumentException createStreamingSourceNotSpecifySchemaError()

streamedOperatorUnsupportedByDataSourceError

public static org.apache.spark.SparkUnsupportedOperationException streamedOperatorUnsupportedByDataSourceError(String className,
                                                                                                               String operator)

nonTimeWindowNotSupportedInStreamingError

public static AnalysisException nonTimeWindowNotSupportedInStreamingError(scala.collection.Seq<String> windowFuncList,
                                                                          scala.collection.Seq<String> columnNameList,
                                                                          scala.collection.Seq<String> windowSpecList,
                                                                          org.apache.spark.sql.catalyst.trees.Origin origin)

multiplePathsSpecifiedError

public static org.apache.spark.SparkIllegalArgumentException multiplePathsSpecifiedError(scala.collection.Seq<String> allPaths)

dataSourceNotFoundError

public static org.apache.spark.SparkClassNotFoundException dataSourceNotFoundError(String provider,
                                                                                   Throwable error)

removedClassInSpark2Error

public static org.apache.spark.SparkClassNotFoundException removedClassInSpark2Error(String className,
                                                                                     Throwable e)

incompatibleDataSourceRegisterError

public static Throwable incompatibleDataSourceRegisterError(Throwable e)

sparkUpgradeInReadingDatesError

public static org.apache.spark.SparkUpgradeException sparkUpgradeInReadingDatesError(String format,
                                                                                     String config,
                                                                                     String option)

sparkUpgradeInWritingDatesError

public static org.apache.spark.SparkUpgradeException sparkUpgradeInWritingDatesError(String format,
                                                                                     String config)

buildReaderUnsupportedForFileFormatError

public static org.apache.spark.SparkUnsupportedOperationException buildReaderUnsupportedForFileFormatError(String format)

taskFailedWhileWritingRowsError

public static Throwable taskFailedWhileWritingRowsError(String path,
                                                        Throwable cause)

readCurrentFileNotFoundError

public static org.apache.spark.SparkFileNotFoundException readCurrentFileNotFoundError(java.io.FileNotFoundException e)

saveModeUnsupportedError

public static Throwable saveModeUnsupportedError(Object saveMode,
                                                 boolean pathExists)

cannotClearOutputDirectoryError

public static Throwable cannotClearOutputDirectoryError(org.apache.hadoop.fs.Path staticPrefixPath)

cannotClearPartitionDirectoryError

public static Throwable cannotClearPartitionDirectoryError(org.apache.hadoop.fs.Path path)

failedToCastValueToDataTypeForPartitionColumnError

public static org.apache.spark.SparkRuntimeException failedToCastValueToDataTypeForPartitionColumnError(String value,
                                                                                                        DataType dataType,
                                                                                                        String columnName)

endOfStreamError

public static Throwable endOfStreamError()

fallbackV1RelationReportsInconsistentSchemaError

public static org.apache.spark.SparkIllegalArgumentException fallbackV1RelationReportsInconsistentSchemaError(StructType v2Schema,
                                                                                                              StructType v1Schema)

noRecordsFromEmptyDataReaderError

public static Throwable noRecordsFromEmptyDataReaderError()

fileNotFoundError

public static org.apache.spark.SparkFileNotFoundException fileNotFoundError(java.io.FileNotFoundException e)

unsupportedSchemaColumnConvertError

public static Throwable unsupportedSchemaColumnConvertError(String filePath,
                                                            String column,
                                                            String logicalType,
                                                            String physicalType,
                                                            Exception e)

cannotReadFilesError

public static Throwable cannotReadFilesError(Throwable e,
                                             String path)

cannotCreateColumnarReaderError

public static Throwable cannotCreateColumnarReaderError()

invalidNamespaceNameError

public static org.apache.spark.SparkIllegalArgumentException invalidNamespaceNameError(String[] namespace)

unsupportedPartitionTransformError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedPartitionTransformError(Transform transform)

missingDatabaseLocationError

public static org.apache.spark.SparkIllegalArgumentException missingDatabaseLocationError()

cannotRemoveReservedPropertyError

public static org.apache.spark.SparkUnsupportedOperationException cannotRemoveReservedPropertyError(String property)

writingJobFailedError

public static Throwable writingJobFailedError(Throwable cause)

commitDeniedError

public static Throwable commitDeniedError(int partId,
                                          long taskId,
                                          int attemptId,
                                          int stageId,
                                          int stageAttempt)

cannotCreateJDBCTableWithPartitionsError

public static org.apache.spark.SparkUnsupportedOperationException cannotCreateJDBCTableWithPartitionsError()

unsupportedUserSpecifiedSchemaError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedUserSpecifiedSchemaError()

writeUnsupportedForBinaryFileDataSourceError

public static org.apache.spark.SparkUnsupportedOperationException writeUnsupportedForBinaryFileDataSourceError()

fileLengthExceedsMaxLengthError

public static Throwable fileLengthExceedsMaxLengthError(org.apache.hadoop.fs.FileStatus status,
                                                        int maxLength)

unsupportedFieldNameError

public static org.apache.spark.SparkRuntimeException unsupportedFieldNameError(String fieldName)

cannotSpecifyBothJdbcTableNameAndQueryError

public static org.apache.spark.SparkIllegalArgumentException cannotSpecifyBothJdbcTableNameAndQueryError(String jdbcTableName,
                                                                                                         String jdbcQueryString)

missingJdbcTableNameAndQueryError

public static org.apache.spark.SparkIllegalArgumentException missingJdbcTableNameAndQueryError(String jdbcTableName,
                                                                                               String jdbcQueryString)

emptyOptionError

public static org.apache.spark.SparkIllegalArgumentException emptyOptionError(String optionName)

invalidJdbcTxnIsolationLevelError

public static org.apache.spark.SparkIllegalArgumentException invalidJdbcTxnIsolationLevelError(String jdbcTxnIsolationLevel,
                                                                                               String value)

cannotGetJdbcTypeError

public static org.apache.spark.SparkIllegalArgumentException cannotGetJdbcTypeError(DataType dt)

unrecognizedSqlTypeError

public static Throwable unrecognizedSqlTypeError(String jdbcTypeId,
                                                 String typeName)

unsupportedJdbcTypeError

public static org.apache.spark.SparkSQLException unsupportedJdbcTypeError(String content)

unsupportedArrayElementTypeBasedOnBinaryError

public static org.apache.spark.SparkIllegalArgumentException unsupportedArrayElementTypeBasedOnBinaryError(DataType dt)

nestedArraysUnsupportedError

public static org.apache.spark.SparkIllegalArgumentException nestedArraysUnsupportedError()

cannotTranslateNonNullValueForFieldError

public static org.apache.spark.SparkIllegalArgumentException cannotTranslateNonNullValueForFieldError(int pos)

invalidJdbcNumPartitionsError

public static org.apache.spark.SparkIllegalArgumentException invalidJdbcNumPartitionsError(int n,
                                                                                           String jdbcNumPartitions)

multiActionAlterError

public static Throwable multiActionAlterError(String tableName)

dataTypeUnsupportedYetError

public static org.apache.spark.SparkUnsupportedOperationException dataTypeUnsupportedYetError(DataType dataType)

unsupportedOperationForDataTypeError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedOperationForDataTypeError(DataType dataType)

inputFilterNotFullyConvertibleError

public static Throwable inputFilterNotFullyConvertibleError(String owner)

cannotReadFooterForFileError

public static Throwable cannotReadFooterForFileError(org.apache.hadoop.fs.Path file,
                                                     Exception e)

foundDuplicateFieldInCaseInsensitiveModeError

public static org.apache.spark.SparkRuntimeException foundDuplicateFieldInCaseInsensitiveModeError(String requiredFieldName,
                                                                                                   String matchedOrcFields)

foundDuplicateFieldInFieldIdLookupModeError

public static org.apache.spark.SparkRuntimeException foundDuplicateFieldInFieldIdLookupModeError(int requiredId,
                                                                                                 String matchedFields)

failedToMergeIncompatibleSchemasError

public static Throwable failedToMergeIncompatibleSchemasError(StructType left,
                                                              StructType right,
                                                              Throwable e)

ddlUnsupportedTemporarilyError

public static org.apache.spark.SparkUnsupportedOperationException ddlUnsupportedTemporarilyError(String ddl)

executeBroadcastTimeoutError

public static Throwable executeBroadcastTimeoutError(long timeout,
                                                     scala.Option<java.util.concurrent.TimeoutException> ex)

cannotCompareCostWithTargetCostError

public static org.apache.spark.SparkIllegalArgumentException cannotCompareCostWithTargetCostError(String cost)

notSupportTypeError

public static Throwable notSupportTypeError(DataType dataType)

notSupportNonPrimitiveTypeError

public static org.apache.spark.SparkRuntimeException notSupportNonPrimitiveTypeError()

unsupportedTypeError

public static Throwable unsupportedTypeError(DataType dataType)

useDictionaryEncodingWhenDictionaryOverflowError

public static Throwable useDictionaryEncodingWhenDictionaryOverflowError()

endOfIteratorError

public static Throwable endOfIteratorError()

cannotAllocateMemoryToGrowBytesToBytesMapError

public static Throwable cannotAllocateMemoryToGrowBytesToBytesMapError()

cannotAcquireMemoryToBuildLongHashedRelationError

public static Throwable cannotAcquireMemoryToBuildLongHashedRelationError(long size,
                                                                          long got)

cannotAcquireMemoryToBuildUnsafeHashedRelationError

public static Throwable cannotAcquireMemoryToBuildUnsafeHashedRelationError()

rowLargerThan256MUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException rowLargerThan256MUnsupportedError()

cannotBuildHashedRelationWithUniqueKeysExceededError

public static org.apache.spark.SparkUnsupportedOperationException cannotBuildHashedRelationWithUniqueKeysExceededError()

cannotBuildHashedRelationLargerThan8GError

public static org.apache.spark.SparkUnsupportedOperationException cannotBuildHashedRelationLargerThan8GError()

failedToPushRowIntoRowQueueError

public static Throwable failedToPushRowIntoRowQueueError(String rowQueue)

unexpectedWindowFunctionFrameError

public static org.apache.spark.SparkRuntimeException unexpectedWindowFunctionFrameError(String frame)

cannotParseStatisticAsPercentileError

public static org.apache.spark.SparkIllegalArgumentException cannotParseStatisticAsPercentileError(String stats,
                                                                                                   NumberFormatException e)

statisticNotRecognizedError

public static org.apache.spark.SparkIllegalArgumentException statisticNotRecognizedError(String stats)

unknownColumnError

public static org.apache.spark.SparkIllegalArgumentException unknownColumnError(String unknownColumn)

unexpectedAccumulableUpdateValueError

public static org.apache.spark.SparkIllegalArgumentException unexpectedAccumulableUpdateValueError(Object o)

unscaledValueTooLargeForPrecisionError

public static ArithmeticException unscaledValueTooLargeForPrecisionError(Decimal value,
                                                                         int decimalPrecision,
                                                                         int decimalScale,
                                                                         org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

decimalPrecisionExceedsMaxPrecisionError

public static org.apache.spark.SparkArithmeticException decimalPrecisionExceedsMaxPrecisionError(int precision,
                                                                                                 int maxPrecision)

outOfDecimalTypeRangeError

public static org.apache.spark.SparkArithmeticException outOfDecimalTypeRangeError(org.apache.spark.unsafe.types.UTF8String str)

unsupportedArrayTypeError

public static org.apache.spark.SparkRuntimeException unsupportedArrayTypeError(Class<?> clazz)

unsupportedJavaTypeError

public static org.apache.spark.SparkRuntimeException unsupportedJavaTypeError(Class<?> clazz)

failedParsingStructTypeError

public static org.apache.spark.SparkRuntimeException failedParsingStructTypeError(String raw)

cannotMergeDecimalTypesWithIncompatibleScaleError

public static Throwable cannotMergeDecimalTypesWithIncompatibleScaleError(int leftScale,
                                                                          int rightScale)

cannotMergeIncompatibleDataTypesError

public static Throwable cannotMergeIncompatibleDataTypesError(DataType left,
                                                              DataType right)

exceedMapSizeLimitError

public static org.apache.spark.SparkRuntimeException exceedMapSizeLimitError(int size)

duplicateMapKeyFoundError

public static org.apache.spark.SparkRuntimeException duplicateMapKeyFoundError(Object key)

mapDataKeyArrayLengthDiffersFromValueArrayLengthError

public static org.apache.spark.SparkRuntimeException mapDataKeyArrayLengthDiffersFromValueArrayLengthError()

registeringStreamingQueryListenerError

public static Throwable registeringStreamingQueryListenerError(Exception e)

concurrentQueryInstanceError

public static Throwable concurrentQueryInstanceError()

concurrentStreamLogUpdate

public static Throwable concurrentStreamLogUpdate(long batchId)

cannotParseJsonArraysAsStructsError

public static org.apache.spark.SparkRuntimeException cannotParseJsonArraysAsStructsError(String recordStr)

cannotParseStringAsDataTypeError

public static org.apache.spark.SparkRuntimeException cannotParseStringAsDataTypeError(com.fasterxml.jackson.core.JsonParser parser,
                                                                                      com.fasterxml.jackson.core.JsonToken token,
                                                                                      DataType dataType)

emptyJsonFieldValueError

public static org.apache.spark.SparkRuntimeException emptyJsonFieldValueError(DataType dataType)

cannotParseJSONFieldError

public static org.apache.spark.SparkRuntimeException cannotParseJSONFieldError(com.fasterxml.jackson.core.JsonParser parser,
                                                                               com.fasterxml.jackson.core.JsonToken jsonType,
                                                                               DataType dataType)

cannotParseJSONFieldError

public static org.apache.spark.SparkRuntimeException cannotParseJSONFieldError(String fieldName,
                                                                               String fieldValue,
                                                                               com.fasterxml.jackson.core.JsonToken jsonType,
                                                                               DataType dataType)

rootConverterReturnNullError

public static org.apache.spark.SparkRuntimeException rootConverterReturnNullError()

attributesForTypeUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException attributesForTypeUnsupportedError(org.apache.spark.sql.catalyst.ScalaReflection.Schema schema)

paramExceedOneCharError

public static org.apache.spark.SparkRuntimeException paramExceedOneCharError(String paramName)

paramIsNotIntegerError

public static org.apache.spark.SparkRuntimeException paramIsNotIntegerError(String paramName,
                                                                            String value)

paramIsNotBooleanValueError

public static Throwable paramIsNotBooleanValueError(String paramName)

foundNullValueForNotNullableFieldError

public static org.apache.spark.SparkRuntimeException foundNullValueForNotNullableFieldError(String name)

malformedCSVRecordError

public static org.apache.spark.SparkRuntimeException malformedCSVRecordError(String badRecord)

elementsOfTupleExceedLimitError

public static org.apache.spark.SparkUnsupportedOperationException elementsOfTupleExceedLimitError()

expressionDecodingError

public static org.apache.spark.SparkRuntimeException expressionDecodingError(Exception e,
                                                                             scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> expressions)

expressionEncodingError

public static org.apache.spark.SparkRuntimeException expressionEncodingError(Exception e,
                                                                             scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> expressions)

classHasUnexpectedSerializerError

public static org.apache.spark.SparkRuntimeException classHasUnexpectedSerializerError(String clsName,
                                                                                       org.apache.spark.sql.catalyst.expressions.Expression objSerializer)

unsupportedOperandTypeForSizeFunctionError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedOperandTypeForSizeFunctionError(DataType dataType)

unexpectedValueForStartInFunctionError

public static org.apache.spark.SparkRuntimeException unexpectedValueForStartInFunctionError(String prettyName)

unexpectedValueForLengthInFunctionError

public static org.apache.spark.SparkRuntimeException unexpectedValueForLengthInFunctionError(String prettyName)

invalidIndexOfZeroError

public static RuntimeException invalidIndexOfZeroError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

concatArraysWithElementsExceedLimitError

public static org.apache.spark.SparkRuntimeException concatArraysWithElementsExceedLimitError(long numberOfElements)

flattenArraysWithElementsExceedLimitError

public static org.apache.spark.SparkRuntimeException flattenArraysWithElementsExceedLimitError(long numberOfElements)

createArrayWithElementsExceedLimitError

public static org.apache.spark.SparkRuntimeException createArrayWithElementsExceedLimitError(Object count)

unionArrayWithElementsExceedLimitError

public static org.apache.spark.SparkRuntimeException unionArrayWithElementsExceedLimitError(int length)

initialTypeNotTargetDataTypeError

public static org.apache.spark.SparkUnsupportedOperationException initialTypeNotTargetDataTypeError(DataType dataType,
                                                                                                    String target)

initialTypeNotTargetDataTypesError

public static org.apache.spark.SparkUnsupportedOperationException initialTypeNotTargetDataTypesError(DataType dataType)

malformedRecordsDetectedInSchemaInferenceError

public static Throwable malformedRecordsDetectedInSchemaInferenceError(Throwable e)

malformedJSONError

public static Throwable malformedJSONError()

malformedRecordsDetectedInSchemaInferenceError

public static Throwable malformedRecordsDetectedInSchemaInferenceError(DataType dataType)

decorrelateInnerQueryThroughPlanUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException decorrelateInnerQueryThroughPlanUnsupportedError(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan)

methodCalledInAnalyzerNotAllowedError

public static org.apache.spark.SparkRuntimeException methodCalledInAnalyzerNotAllowedError()

cannotSafelyMergeSerdePropertiesError

public static org.apache.spark.SparkUnsupportedOperationException cannotSafelyMergeSerdePropertiesError(scala.collection.immutable.Map<String,String> props1,
                                                                                                        scala.collection.immutable.Map<String,String> props2,
                                                                                                        scala.collection.immutable.Set<String> conflictKeys)

pairUnsupportedAtFunctionError

public static org.apache.spark.SparkUnsupportedOperationException pairUnsupportedAtFunctionError(org.apache.spark.sql.catalyst.plans.logical.statsEstimation.ValueInterval r1,
                                                                                                 org.apache.spark.sql.catalyst.plans.logical.statsEstimation.ValueInterval r2,
                                                                                                 String function)

onceStrategyIdempotenceIsBrokenForBatchError

public static <TreeType extends org.apache.spark.sql.catalyst.trees.TreeNode<?>> org.apache.spark.SparkRuntimeException onceStrategyIdempotenceIsBrokenForBatchError(String batchName,
                                                                                                                                                                     TreeType plan,
                                                                                                                                                                     TreeType reOptimized)

ruleIdNotFoundForRuleError

public static Throwable ruleIdNotFoundForRuleError(String ruleName)

cannotCreateArrayWithElementsExceedLimitError

public static org.apache.spark.SparkRuntimeException cannotCreateArrayWithElementsExceedLimitError(long numElements,
                                                                                                   String additionalErrorMessage)

malformedRecordsDetectedInRecordParsingError

public static Throwable malformedRecordsDetectedInRecordParsingError(String badRecord,
                                                                     org.apache.spark.sql.catalyst.util.BadRecordException e)

remoteOperationsUnsupportedError

public static org.apache.spark.SparkRuntimeException remoteOperationsUnsupportedError()

invalidKerberosConfigForHiveServer2Error

public static Throwable invalidKerberosConfigForHiveServer2Error()

parentSparkUIToAttachTabNotFoundError

public static Throwable parentSparkUIToAttachTabNotFoundError()

inferSchemaUnsupportedForHiveError

public static org.apache.spark.SparkUnsupportedOperationException inferSchemaUnsupportedForHiveError()

requestedPartitionsMismatchTablePartitionsError

public static Throwable requestedPartitionsMismatchTablePartitionsError(org.apache.spark.sql.catalyst.catalog.CatalogTable table,
                                                                        scala.collection.immutable.Map<String,scala.Option<String>> partition)

dynamicPartitionKeyNotAmongWrittenPartitionPathsError

public static Throwable dynamicPartitionKeyNotAmongWrittenPartitionPathsError(String key)

cannotRemovePartitionDirError

public static org.apache.spark.SparkRuntimeException cannotRemovePartitionDirError(org.apache.hadoop.fs.Path partitionPath)

cannotCreateStagingDirError

public static org.apache.spark.SparkRuntimeException cannotCreateStagingDirError(String message,
                                                                                 java.io.IOException e)

serDeInterfaceNotFoundError

public static org.apache.spark.SparkClassNotFoundException serDeInterfaceNotFoundError(NoClassDefFoundError e)

convertHiveTableToCatalogTableError

public static Throwable convertHiveTableToCatalogTableError(SparkException e,
                                                            String dbName,
                                                            String tableName)

cannotRecognizeHiveTypeError

public static Throwable cannotRecognizeHiveTypeError(org.apache.spark.sql.catalyst.parser.ParseException e,
                                                     String fieldType,
                                                     String fieldName)

getTablesByTypeUnsupportedByHiveVersionError

public static org.apache.spark.SparkUnsupportedOperationException getTablesByTypeUnsupportedByHiveVersionError()

dropTableWithPurgeUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException dropTableWithPurgeUnsupportedError()

alterTableWithDropPartitionAndPurgeUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException alterTableWithDropPartitionAndPurgeUnsupportedError()

invalidPartitionFilterError

public static org.apache.spark.SparkUnsupportedOperationException invalidPartitionFilterError()

getPartitionMetadataByFilterError

public static org.apache.spark.SparkRuntimeException getPartitionMetadataByFilterError(java.lang.reflect.InvocationTargetException e)

unsupportedHiveMetastoreVersionError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedHiveMetastoreVersionError(String version,
                                                                                                       String key)

loadHiveClientCausesNoClassDefFoundError

public static org.apache.spark.SparkClassNotFoundException loadHiveClientCausesNoClassDefFoundError(NoClassDefFoundError cnf,
                                                                                                    scala.collection.Seq<java.net.URL> execJars,
                                                                                                    String key,
                                                                                                    java.lang.reflect.InvocationTargetException e)

cannotFetchTablesOfDatabaseError

public static Throwable cannotFetchTablesOfDatabaseError(String dbName,
                                                         Exception e)

illegalLocationClauseForViewPartitionError

public static Throwable illegalLocationClauseForViewPartitionError()

renamePathAsExistsPathError

public static Throwable renamePathAsExistsPathError(org.apache.hadoop.fs.Path srcPath,
                                                    org.apache.hadoop.fs.Path dstPath)

renameAsExistsPathError

public static org.apache.spark.SparkFileAlreadyExistsException renameAsExistsPathError(org.apache.hadoop.fs.Path dstPath)

renameSrcPathNotFoundError

public static Throwable renameSrcPathNotFoundError(org.apache.hadoop.fs.Path srcPath)

failedRenameTempFileError

public static Throwable failedRenameTempFileError(org.apache.hadoop.fs.Path srcPath,
                                                  org.apache.hadoop.fs.Path dstPath)

legacyMetadataPathExistsError

public static Throwable legacyMetadataPathExistsError(org.apache.hadoop.fs.Path metadataPath,
                                                      org.apache.hadoop.fs.Path legacyMetadataPath)

partitionColumnNotFoundInSchemaError

public static org.apache.spark.SparkRuntimeException partitionColumnNotFoundInSchemaError(String col,
                                                                                          StructType schema)

stateNotDefinedOrAlreadyRemovedError

public static Throwable stateNotDefinedOrAlreadyRemovedError()

cannotSetTimeoutDurationError

public static org.apache.spark.SparkUnsupportedOperationException cannotSetTimeoutDurationError()

cannotGetEventTimeWatermarkError

public static org.apache.spark.SparkUnsupportedOperationException cannotGetEventTimeWatermarkError()

cannotSetTimeoutTimestampError

public static org.apache.spark.SparkUnsupportedOperationException cannotSetTimeoutTimestampError()

batchMetadataFileNotFoundError

public static org.apache.spark.SparkFileNotFoundException batchMetadataFileNotFoundError(org.apache.hadoop.fs.Path batchMetadataFile)

multiStreamingQueriesUsingPathConcurrentlyError

public static org.apache.spark.SparkConcurrentModificationException multiStreamingQueriesUsingPathConcurrentlyError(String path,
                                                                                                                    org.apache.hadoop.fs.FileAlreadyExistsException e)

addFilesWithAbsolutePathUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException addFilesWithAbsolutePathUnsupportedError(String commitProtocol)

microBatchUnsupportedByDataSourceError

public static org.apache.spark.SparkUnsupportedOperationException microBatchUnsupportedByDataSourceError(String srcName,
                                                                                                         String disabledSources,
                                                                                                         Table table)

cannotExecuteStreamingRelationExecError

public static org.apache.spark.SparkUnsupportedOperationException cannotExecuteStreamingRelationExecError()

invalidStreamingOutputModeError

public static org.apache.spark.SparkUnsupportedOperationException invalidStreamingOutputModeError(scala.Option<OutputMode> outputMode)

invalidCatalogNameError

public static Throwable invalidCatalogNameError(String name)

catalogPluginClassNotFoundError

public static Throwable catalogPluginClassNotFoundError(String name)

catalogPluginClassNotImplementedError

public static Throwable catalogPluginClassNotImplementedError(String name,
                                                              String pluginClassName)

catalogPluginClassNotFoundForCatalogError

public static Throwable catalogPluginClassNotFoundForCatalogError(String name,
                                                                  String pluginClassName,
                                                                  Exception e)

catalogFailToFindPublicNoArgConstructorError

public static Throwable catalogFailToFindPublicNoArgConstructorError(String name,
                                                                     String pluginClassName,
                                                                     Exception e)

catalogFailToCallPublicNoArgConstructorError

public static Throwable catalogFailToCallPublicNoArgConstructorError(String name,
                                                                     String pluginClassName,
                                                                     Exception e)

cannotInstantiateAbstractCatalogPluginClassError

public static Throwable cannotInstantiateAbstractCatalogPluginClassError(String name,
                                                                         String pluginClassName,
                                                                         Exception e)

failedToInstantiateConstructorForCatalogError

public static Throwable failedToInstantiateConstructorForCatalogError(String name,
                                                                      String pluginClassName,
                                                                      Exception e)

noSuchElementExceptionError

public static Throwable noSuchElementExceptionError()

sqlConfigNotFoundError

public static org.apache.spark.SparkNoSuchElementException sqlConfigNotFoundError(String key)

cannotMutateReadOnlySQLConfError

public static org.apache.spark.SparkUnsupportedOperationException cannotMutateReadOnlySQLConfError()

cannotCloneOrCopyReadOnlySQLConfError

public static org.apache.spark.SparkUnsupportedOperationException cannotCloneOrCopyReadOnlySQLConfError()

cannotGetSQLConfInSchedulerEventLoopThreadError

public static org.apache.spark.SparkRuntimeException cannotGetSQLConfInSchedulerEventLoopThreadError()

unsupportedOperationExceptionError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedOperationExceptionError()

nullLiteralsCannotBeCastedError

public static org.apache.spark.SparkUnsupportedOperationException nullLiteralsCannotBeCastedError(String name)

notUserDefinedTypeError

public static Throwable notUserDefinedTypeError(String name,
                                                String userClass)

cannotLoadUserDefinedTypeError

public static Throwable cannotLoadUserDefinedTypeError(String name,
                                                       String userClass)

notPublicClassError

public static org.apache.spark.SparkUnsupportedOperationException notPublicClassError(String name)

primitiveTypesNotSupportedError

public static org.apache.spark.SparkUnsupportedOperationException primitiveTypesNotSupportedError()

fieldIndexOnRowWithoutSchemaError

public static org.apache.spark.SparkUnsupportedOperationException fieldIndexOnRowWithoutSchemaError()

valueIsNullError

public static Throwable valueIsNullError(int index)

onlySupportDataSourcesProvidingFileFormatError

public static Throwable onlySupportDataSourcesProvidingFileFormatError(String providingClass)

cannotRestorePermissionsForPathError

public static Throwable cannotRestorePermissionsForPathError(org.apache.hadoop.fs.permission.FsPermission permission,
                                                             org.apache.hadoop.fs.Path path)

failToSetOriginalACLBackError

public static org.apache.spark.SparkSecurityException failToSetOriginalACLBackError(String aclEntries,
                                                                                    org.apache.hadoop.fs.Path path,
                                                                                    Throwable e)

multiFailuresInStageMaterializationError

public static Throwable multiFailuresInStageMaterializationError(Throwable error)

unrecognizedCompressionSchemaTypeIDError

public static org.apache.spark.SparkUnsupportedOperationException unrecognizedCompressionSchemaTypeIDError(int typeId)

getParentLoggerNotImplementedError

public static org.apache.spark.SparkSQLFeatureNotSupportedException getParentLoggerNotImplementedError(String className)

cannotCreateParquetConverterForTypeError

public static org.apache.spark.SparkRuntimeException cannotCreateParquetConverterForTypeError(DecimalType t,
                                                                                              String parquetType)

cannotCreateParquetConverterForDecimalTypeError

public static org.apache.spark.SparkRuntimeException cannotCreateParquetConverterForDecimalTypeError(DecimalType t,
                                                                                                     String parquetType)

cannotCreateParquetConverterForDataTypeError

public static org.apache.spark.SparkRuntimeException cannotCreateParquetConverterForDataTypeError(DataType t,
                                                                                                  String parquetType)

cannotAddMultiPartitionsOnNonatomicPartitionTableError

public static org.apache.spark.SparkUnsupportedOperationException cannotAddMultiPartitionsOnNonatomicPartitionTableError(String tableName)

userSpecifiedSchemaUnsupportedByDataSourceError

public static org.apache.spark.SparkUnsupportedOperationException userSpecifiedSchemaUnsupportedByDataSourceError(TableProvider provider)

cannotDropMultiPartitionsOnNonatomicPartitionTableError

public static org.apache.spark.SparkUnsupportedOperationException cannotDropMultiPartitionsOnNonatomicPartitionTableError(String tableName)

truncateMultiPartitionUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException truncateMultiPartitionUnsupportedError(String tableName)

overwriteTableByUnsupportedExpressionError

public static Throwable overwriteTableByUnsupportedExpressionError(Table table)

dynamicPartitionOverwriteUnsupportedByTableError

public static Throwable dynamicPartitionOverwriteUnsupportedByTableError(Table table)

failedMergingSchemaError

public static Throwable failedMergingSchemaError(StructType leftSchema,
                                                 StructType rightSchema,
                                                 SparkException e)

cannotBroadcastTableOverMaxTableRowsError

public static Throwable cannotBroadcastTableOverMaxTableRowsError(long maxBroadcastTableRows,
                                                                  long numRows)

cannotBroadcastTableOverMaxTableBytesError

public static Throwable cannotBroadcastTableOverMaxTableBytesError(long maxBroadcastTableBytes,
                                                                   long dataSize)

notEnoughMemoryToBuildAndBroadcastTableError

public static Throwable notEnoughMemoryToBuildAndBroadcastTableError(OutOfMemoryError oe,
                                                                     scala.collection.Seq<org.apache.spark.sql.catalyst.TableIdentifier> tables)

executeCodePathUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException executeCodePathUnsupportedError(String execName)

cannotMergeClassWithOtherClassError

public static org.apache.spark.SparkUnsupportedOperationException cannotMergeClassWithOtherClassError(String className,
                                                                                                      String otherClass)

continuousProcessingUnsupportedByDataSourceError

public static org.apache.spark.SparkUnsupportedOperationException continuousProcessingUnsupportedByDataSourceError(String sourceName)

failedToReadDataError

public static Throwable failedToReadDataError(Throwable failureReason)

failedToGenerateEpochMarkerError

public static Throwable failedToGenerateEpochMarkerError(Throwable failureReason)

foreachWriterAbortedDueToTaskFailureError

public static Throwable foreachWriterAbortedDueToTaskFailureError()

incorrectRampUpRate

public static Throwable incorrectRampUpRate(long rowsPerSecond,
                                            long maxSeconds,
                                            long rampUpTimeSeconds)

incorrectEndOffset

public static Throwable incorrectEndOffset(long rowsPerSecond,
                                           long maxSeconds,
                                           long endSeconds)

failedToReadDeltaFileError

public static Throwable failedToReadDeltaFileError(org.apache.hadoop.fs.Path fileToRead,
                                                   String clazz,
                                                   int keySize)

failedToReadSnapshotFileError

public static Throwable failedToReadSnapshotFileError(org.apache.hadoop.fs.Path fileToRead,
                                                      String clazz,
                                                      String message)

cannotPurgeAsBreakInternalStateError

public static org.apache.spark.SparkUnsupportedOperationException cannotPurgeAsBreakInternalStateError()

cleanUpSourceFilesUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException cleanUpSourceFilesUnsupportedError()

latestOffsetNotCalledError

public static org.apache.spark.SparkUnsupportedOperationException latestOffsetNotCalledError()

legacyCheckpointDirectoryExistsError

public static Throwable legacyCheckpointDirectoryExistsError(org.apache.hadoop.fs.Path checkpointPath,
                                                             String legacyCheckpointDir)

subprocessExitedError

public static Throwable subprocessExitedError(int exitCode,
                                              org.apache.spark.util.CircularBuffer stderrBuffer,
                                              Throwable cause)

outputDataTypeUnsupportedByNodeWithoutSerdeError

public static Throwable outputDataTypeUnsupportedByNodeWithoutSerdeError(String nodeName,
                                                                         DataType dt)

invalidStartIndexError

public static org.apache.spark.SparkArrayIndexOutOfBoundsException invalidStartIndexError(int numRows,
                                                                                          int startIndex)

concurrentModificationOnExternalAppendOnlyUnsafeRowArrayError

public static org.apache.spark.SparkConcurrentModificationException concurrentModificationOnExternalAppendOnlyUnsafeRowArrayError(String className)

doExecuteBroadcastNotImplementedError

public static org.apache.spark.SparkUnsupportedOperationException doExecuteBroadcastNotImplementedError(String nodeName)

defaultDatabaseNotExistsError

public static Throwable defaultDatabaseNotExistsError(String defaultDatabase)

databaseNameConflictWithSystemPreservedDatabaseError

public static Throwable databaseNameConflictWithSystemPreservedDatabaseError(String globalTempDB)

commentOnTableUnsupportedError

public static org.apache.spark.SparkSQLFeatureNotSupportedException commentOnTableUnsupportedError()

unsupportedUpdateColumnNullabilityError

public static org.apache.spark.SparkSQLFeatureNotSupportedException unsupportedUpdateColumnNullabilityError()

renameColumnUnsupportedForOlderMySQLError

public static org.apache.spark.SparkSQLFeatureNotSupportedException renameColumnUnsupportedForOlderMySQLError()

failedToExecuteQueryError

public static SparkException failedToExecuteQueryError(Throwable e)

nestedFieldUnsupportedError

public static org.apache.spark.SparkUnsupportedOperationException nestedFieldUnsupportedError(String colName)

transformationsAndActionsNotInvokedByDriverError

public static Throwable transformationsAndActionsNotInvokedByDriverError()

repeatedPivotsUnsupportedError

public static Throwable repeatedPivotsUnsupportedError(String clause,
                                                       String operation)

pivotNotAfterGroupByUnsupportedError

public static Throwable pivotNotAfterGroupByUnsupportedError()

invalidAesKeyLengthError

public static RuntimeException invalidAesKeyLengthError(int actualLength)

aesModeUnsupportedError

public static RuntimeException aesModeUnsupportedError(String mode,
                                                       String padding)

aesCryptoError

public static RuntimeException aesCryptoError(String detailMessage)

invalidAesIvLengthError

public static RuntimeException invalidAesIvLengthError(String mode,
                                                       int actualLength)

aesUnsupportedIv

public static RuntimeException aesUnsupportedIv(String mode)

aesUnsupportedAad

public static RuntimeException aesUnsupportedAad(String mode)

hiveTableWithAnsiIntervalsError

public static org.apache.spark.SparkUnsupportedOperationException hiveTableWithAnsiIntervalsError(org.apache.spark.sql.catalyst.TableIdentifier table)

cannotConvertOrcTimestampToTimestampNTZError

public static Throwable cannotConvertOrcTimestampToTimestampNTZError()

cannotConvertOrcTimestampNTZToTimestampLTZError

public static Throwable cannotConvertOrcTimestampNTZToTimestampLTZError()

writePartitionExceedConfigSizeWhenDynamicPartitionError

public static Throwable writePartitionExceedConfigSizeWhenDynamicPartitionError(int numWrittenParts,
                                                                                int maxDynamicPartitions,
                                                                                String maxDynamicPartitionsKey)

invalidNumberFormatError

public static org.apache.spark.SparkIllegalArgumentException invalidNumberFormatError(DataType dataType,
                                                                                      String input,
                                                                                      String format)

unsupportedMultipleBucketTransformsError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedMultipleBucketTransformsError()

unsupportedCommentNamespaceError

public static org.apache.spark.SparkSQLFeatureNotSupportedException unsupportedCommentNamespaceError(String namespace)

unsupportedRemoveNamespaceCommentError

public static org.apache.spark.SparkSQLFeatureNotSupportedException unsupportedRemoveNamespaceCommentError(String namespace)

unsupportedDropNamespaceError

public static org.apache.spark.SparkSQLFeatureNotSupportedException unsupportedDropNamespaceError(String namespace)

exceedMaxLimit

public static org.apache.spark.SparkRuntimeException exceedMaxLimit(int limit)

timestampAddOverflowError

public static ArithmeticException timestampAddOverflowError(long micros,
                                                            int amount,
                                                            String unit)

invalidBucketFile

public static Throwable invalidBucketFile(String path)

multipleRowSubqueryError

public static Throwable multipleRowSubqueryError(org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

comparatorReturnsNull

public static Throwable comparatorReturnsNull(String firstValue,
                                              String secondValue)

invalidPatternError

public static RuntimeException invalidPatternError(String funcName,
                                                   String pattern,
                                                   Throwable cause)

tooManyArrayElementsError

public static org.apache.spark.SparkIllegalArgumentException tooManyArrayElementsError(int numElements,
                                                                                       int elementSize)

invalidEmptyLocationError

public static org.apache.spark.SparkIllegalArgumentException invalidEmptyLocationError(String location)

malformedProtobufMessageDetectedInMessageParsingError

public static Throwable malformedProtobufMessageDetectedInMessageParsingError(Throwable e)

locationAlreadyExists

public static Throwable locationAlreadyExists(org.apache.spark.sql.catalyst.TableIdentifier tableId,
                                              org.apache.hadoop.fs.Path location)

cannotConvertCatalystValueToProtobufEnumTypeError

public static Throwable cannotConvertCatalystValueToProtobufEnumTypeError(scala.collection.Seq<String> sqlColumn,
                                                                          String protobufColumn,
                                                                          String data,
                                                                          String enumString)

hllInvalidLgK

public static Throwable hllInvalidLgK(String function,
                                      int min,
                                      int max,
                                      String value)

hllInvalidInputSketchBuffer

public static Throwable hllInvalidInputSketchBuffer(String function)

hllUnionDifferentLgK

public static Throwable hllUnionDifferentLgK(int left,
                                             int right,
                                             String function)

mergeCardinalityViolationError

public static org.apache.spark.SparkRuntimeException mergeCardinalityViolationError()

unsupportedPurgePartitionError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedPurgePartitionError()

unsupportedPurgeTableError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedPurgeTableError()

toSQLId

public static String toSQLId(String parts)

toSQLId

public static String toSQLId(scala.collection.Seq<String> parts)

toSQLStmt

public static String toSQLStmt(String text)

toSQLConf

public static String toSQLConf(String conf)

toSQLType

public static String toSQLType(String text)

toSQLType

public static String toSQLType(org.apache.spark.sql.types.AbstractDataType t)

toSQLValue

public static String toSQLValue(String value)

toSQLValue

public static String toSQLValue(org.apache.spark.unsafe.types.UTF8String value)

toSQLValue

public static String toSQLValue(short value)

toSQLValue

public static String toSQLValue(int value)

toSQLValue

public static String toSQLValue(long value)

toSQLValue

public static String toSQLValue(float value)

toSQLValue

public static String toSQLValue(double value)

getSummary

public static String getSummary(org.apache.spark.sql.catalyst.trees.SQLQueryContext sqlContext)

getQueryContext

public static QueryContext[] getQueryContext(org.apache.spark.sql.catalyst.trees.SQLQueryContext sqlContext)

toSQLConfVal

public static String toSQLConfVal(String conf)

toDSOption

public static String toDSOption(String option)

toSQLExpr

public static String toSQLExpr(org.apache.spark.sql.catalyst.expressions.Expression e)

toSQLSchema

public static String toSQLSchema(String schema)

toSQLValue

public static String toSQLValue(Object v,
                                DataType t)

fieldDiffersFromDerivedLocalDateError

public static org.apache.spark.SparkDateTimeException fieldDiffersFromDerivedLocalDateError(java.time.temporal.ChronoField field,
                                                                                            int actual,
                                                                                            int expected,
                                                                                            java.time.LocalDate candidate)

failToParseDateTimeInNewParserError

public static org.apache.spark.SparkUpgradeException failToParseDateTimeInNewParserError(String s,
                                                                                         Throwable e)

failToRecognizePatternAfterUpgradeError

public static org.apache.spark.SparkUpgradeException failToRecognizePatternAfterUpgradeError(String pattern,
                                                                                             Throwable e)

failToRecognizePatternError

public static org.apache.spark.SparkRuntimeException failToRecognizePatternError(String pattern,
                                                                                 Throwable e)

unreachableError

public static org.apache.spark.SparkRuntimeException unreachableError(String err)

unreachableError$default$1

public static String unreachableError$default$1()

invalidInputInCastToDatetimeError

public static org.apache.spark.SparkDateTimeException invalidInputInCastToDatetimeError(org.apache.spark.unsafe.types.UTF8String value,
                                                                                        DataType to,
                                                                                        org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

invalidInputInCastToDatetimeError

public static org.apache.spark.SparkDateTimeException invalidInputInCastToDatetimeError(double value,
                                                                                        DataType to,
                                                                                        org.apache.spark.sql.catalyst.trees.SQLQueryContext context)

arithmeticOverflowError$default$2

public static String arithmeticOverflowError$default$2()

arithmeticOverflowError$default$3

public static org.apache.spark.sql.catalyst.trees.SQLQueryContext arithmeticOverflowError$default$3()

unsupportedArrowTypeError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedArrowTypeError(org.apache.arrow.vector.types.pojo.ArrowType typeName)

duplicatedFieldNameInArrowStructError

public static org.apache.spark.SparkUnsupportedOperationException duplicatedFieldNameInArrowStructError(scala.collection.Seq<String> fieldNames)

unsupportedDataTypeError

public static org.apache.spark.SparkUnsupportedOperationException unsupportedDataTypeError(DataType typeName)

userDefinedTypeNotAnnotatedAndRegisteredError

public static Throwable userDefinedTypeNotAnnotatedAndRegisteredError(UserDefinedType<?> udt)

cannotFindEncoderForTypeError

public static org.apache.spark.SparkUnsupportedOperationException cannotFindEncoderForTypeError(String typeName)

cannotHaveCircularReferencesInBeanClassError

public static org.apache.spark.SparkUnsupportedOperationException cannotHaveCircularReferencesInBeanClassError(Class<?> clazz)

cannotFindConstructorForTypeError

public static org.apache.spark.SparkUnsupportedOperationException cannotFindConstructorForTypeError(String tpe)

cannotHaveCircularReferencesInClassError

public static org.apache.spark.SparkUnsupportedOperationException cannotHaveCircularReferencesInClassError(String t)

cannotUseInvalidJavaIdentifierAsFieldNameError

public static org.apache.spark.SparkUnsupportedOperationException cannotUseInvalidJavaIdentifierAsFieldNameError(String fieldName,
                                                                                                                 org.apache.spark.sql.catalyst.WalkedTypePath walkedTypePath)

primaryConstructorNotFoundError

public static org.apache.spark.SparkRuntimeException primaryConstructorNotFoundError(Class<?> cls)

cannotGetOuterPointerForInnerClassError

public static org.apache.spark.SparkRuntimeException cannotGetOuterPointerForInnerClassError(Class<?> innerCls)

Class QueryExecutionErrors

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

QueryExecutionErrors

Method Detail

cannotEvaluateExpressionError

cannotGenerateCodeForExpressionError

cannotTerminateGeneratorError

castingCauseOverflowError

castingCauseOverflowErrorInTableInsert

cannotChangeDecimalPrecisionError

invalidInputSyntaxForBooleanError

invalidInputInCastToNumberError

invalidInputInConversionError

cannotCastFromNullTypeError

cannotCastError

cannotParseDecimalError

dataTypeUnsupportedError

failedExecuteUserDefinedFunctionError

divideByZeroError

intervalDividedByZeroError

invalidArrayIndexError

invalidElementAtIndexError

invalidBitmapPositionError

invalidFractionOfSecondError

ansiDateTimeParseError

ansiDateTimeError

ansiIllegalArgumentError

ansiIllegalArgumentError

overflowInSumOfDecimalError

overflowInIntegralDivideError

overflowInConvError

mapSizeExceedArraySizeWhenZipMapError

literalTypeUnsupportedError

pivotColumnUnsupportedError

noDefaultForDataTypeError

orderedOperationUnsupportedByDataTypeError

orderedOperationUnsupportedByDataTypeError

invalidRegexGroupIndexError

invalidUrlError

illegalUrlError

mergeUnsupportedByWindowFunctionError

dataTypeUnexpectedError

typeUnsupportedError

negativeValueUnexpectedError

addNewFunctionMismatchedWithFunctionError

cannotGenerateCodeForIncomparableTypeError

cannotInterpolateClassIntoCodeBlockError

customCollectionClsNotResolvedError

classUnsupportedByMapObjectsError

nullAsMapKeyNotAllowedError

methodNotDeclaredError

methodNotFoundError

constructorNotFoundError

unsupportedNaturalJoinTypeError

notExpectedUnresolvedEncoderError

unsupportedEncoderError

notOverrideExpectedMethodsError

failToConvertValueToJsonError

unexpectedOperatorInCorrelatedSubquery

unsupportedRoundingMode

resolveCannotHandleNestedSchema

inputExternalRowCannotBeNullError

fieldCannotBeNullMsg

fieldCannotBeNullError

unableToCreateDatabaseAsFailedToCreateDirectoryError

unableToDropDatabaseAsFailedToDeleteDirectoryError

unableToCreateTableAsFailedToCreateDirectoryError

unableToDeletePartitionPathError

unableToDropTableAsFailedToDeleteDirectoryError

unableToRenameTableAsFailedToRenameDirectoryError

unableToCreatePartitionPathError

unableToRenamePartitionPathError

methodNotImplementedError

arithmeticOverflowError

unaryMinusCauseOverflowError

binaryArithmeticCauseOverflowError

intervalArithmeticOverflowError