Package org.apache.spark.sql.errors

Class QueryExecutionErrors

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 Details

    • QueryExecutionErrors

      public QueryExecutionErrors()

  • Method Details

    • 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 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, URISyntaxException e)

    • illegalUrlError

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

    • 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, IOException e)

    • unableToDropDatabaseAsFailedToDeleteDirectoryError

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

    • unableToCreateTableAsFailedToCreateDirectoryError

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

    • unableToDeletePartitionPathError

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

    • unableToDropTableAsFailedToDeleteDirectoryError

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

    • unableToRenameTableAsFailedToRenameDirectoryError

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

    • unableToCreatePartitionPathError

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

    • unableToRenamePartitionPathError

      public static Throwable unableToRenamePartitionPathError(org.apache.hadoop.fs.Path oldPartPath, 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(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(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<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, 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(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<URL> execJars, String key, 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(ChronoField field, int actual, int expected, 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)