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, QueryContext context)

    • invalidInputSyntaxForBooleanError

      public static org.apache.spark.SparkRuntimeException invalidInputSyntaxForBooleanError(org.apache.spark.unsafe.types.UTF8String s, QueryContext context)

    • invalidInputInCastToNumberError

      public static org.apache.spark.SparkNumberFormatException invalidInputInCastToNumberError(DataType to, org.apache.spark.unsafe.types.UTF8String s, QueryContext 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()

    • failedExecuteUserDefinedFunctionError

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

    • divideByZeroError

      public static ArithmeticException divideByZeroError(QueryContext context)

    • intervalDividedByZeroError

      public static ArithmeticException intervalDividedByZeroError(QueryContext context)

    • invalidUTF8StringError

      public static org.apache.spark.SparkIllegalArgumentException invalidUTF8StringError(org.apache.spark.unsafe.types.UTF8String str)

    • invalidArrayIndexError

      public static ArrayIndexOutOfBoundsException invalidArrayIndexError(int index, int numElements, QueryContext context)

    • invalidElementAtIndexError

      public static ArrayIndexOutOfBoundsException invalidElementAtIndexError(int index, int numElements, QueryContext 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)

    • overflowInSumOfDecimalError

      public static ArithmeticException overflowInSumOfDecimalError(QueryContext context)

    • overflowInIntegralDivideError

      public static ArithmeticException overflowInIntegralDivideError(QueryContext context)

    • overflowInConvError

      public static ArithmeticException overflowInConvError(QueryContext 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, org.apache.spark.sql.catalyst.expressions.Expression expr)

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

    • mergeUnsupportedByWindowFunctionError

      public static Throwable mergeUnsupportedByWindowFunctionError(String funcName)

    • 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 Throwable cannotGenerateCodeForIncomparableTypeError(String codeType, DataType dataType)

    • cannotInterpolateClassIntoCodeBlockError

      public static Throwable 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.immutable.Seq<Class<?>> argClasses)

    • constructorNotFoundError

      public static SparkException 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)

    • invalidExpressionEncoderError

      public static Throwable invalidExpressionEncoderError(String encoderType)

    • invalidExternalTypeError

      public static org.apache.spark.SparkRuntimeException invalidExternalTypeError(String actualType, DataType expectedType, org.apache.spark.sql.catalyst.expressions.Expression childExpression)

    • 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)

    • 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)

    • binaryArithmeticCauseOverflowError

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

    • intervalArithmeticOverflowError

      public static ArithmeticException intervalArithmeticOverflowError(String message, String hint, QueryContext 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.immutable.Seq<String> windowFuncList, scala.collection.immutable.Seq<String> columnNameList, scala.collection.immutable.Seq<String> windowSpecList, org.apache.spark.sql.catalyst.trees.Origin origin)

    • multiplePathsSpecifiedError

      public static org.apache.spark.SparkIllegalArgumentException multiplePathsSpecifiedError(scala.collection.immutable.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)

    • 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()

    • fileNotExistError

      public static Throwable fileNotExistError(String path, Exception e)

    • parquetColumnDataTypeMismatchError

      public static Throwable parquetColumnDataTypeMismatchError(String path, String column, String expectedType, String actualType, 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)

    • 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()

    • 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)

    • 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(String recordStr, String fieldName, String fieldValue, 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()

    • 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)

    • expressionDecodingError

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

    • expressionEncodingError

      public static org.apache.spark.SparkRuntimeException expressionEncodingError(Exception e, scala.collection.immutable.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 Throwable unsupportedOperandTypeForSizeFunctionError(DataType dataType)

    • unexpectedValueForStartInFunctionError

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

    • unexpectedValueForLengthInFunctionError

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

    • invalidIndexOfZeroError

      public static RuntimeException invalidIndexOfZeroError(QueryContext context)

    • arrayFunctionWithElementsExceedLimitError

      public static org.apache.spark.SparkRuntimeException arrayFunctionWithElementsExceedLimitError(String prettyName, long numberOfElements)

    • createArrayWithElementsExceedLimitError

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

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

    • 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()

    • invalidPartitionFilterError

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

    • getPartitionMetadataByFilterError

      public static org.apache.spark.SparkRuntimeException getPartitionMetadataByFilterError(Exception 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.immutable.Seq<URL> execJars, String key, InvocationTargetException e)

    • cannotFetchTablesOfDatabaseError

      public static Throwable cannotFetchTablesOfDatabaseError(String dbName, Exception e)

    • 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()

    • statefulOperatorNotMatchInStateMetadataError

      public static org.apache.spark.SparkRuntimeException statefulOperatorNotMatchInStateMetadataError(scala.collection.immutable.Map<Object,String> opsInMetadataSeq, scala.collection.immutable.Map<Object,String> opsInCurBatchSeq)

    • 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()

    • unsupportedOutputModeForStreamingOperationError

      public static org.apache.spark.SparkUnsupportedOperationException unsupportedOutputModeForStreamingOperationError(OutputMode outputMode, String operation)

    • pythonStreamingDataSourceRuntimeError

      public static SparkException pythonStreamingDataSourceRuntimeError(String action, String message)

    • invalidCatalogNameError

      public static Throwable invalidCatalogNameError(String name)

    • catalogNotFoundError

      public static Throwable catalogNotFoundError(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()

    • notPublicClassError

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

    • primitiveTypesNotSupportedError

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

    • 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.immutable.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)

    • failedToReadDeltaFileKeySizeError

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

    • failedToReadDeltaFileNotExistsError

      public static Throwable failedToReadDeltaFileNotExistsError(org.apache.hadoop.fs.Path fileToRead, String clazz, Throwable f)

    • failedToReadSnapshotFileKeySizeError

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

    • failedToReadSnapshotFileValueSizeError

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

    • failedToReadStreamingStateFileError

      public static Throwable failedToReadStreamingStateFileError(org.apache.hadoop.fs.Path fileToRead, Throwable f)

    • failedToCommitStateFileError

      public static Throwable failedToCommitStateFileError(String providerClass, Throwable f)

    • 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)

    • multipleRowScalarSubqueryError

      public static Throwable multipleRowScalarSubqueryError(QueryContext 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(long numElements, int maxRoundedArrayLength)

    • invalidLocationError

      public static org.apache.spark.SparkIllegalArgumentException invalidLocationError(String location, String errorClass, Throwable cause)

    • 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.immutable.Seq<String> sqlColumn, String protobufColumn, String data, String enumString)

    • unreleasedThreadError

      public static Throwable unreleasedThreadError(String loggingId, String opType, String newAcquiredThreadInfo, String acquiredThreadInfo, long timeWaitedMs, String stackTraceOutput)

    • cannotReadCheckpoint

      public static Throwable cannotReadCheckpoint(String expectedVersion, String actualVersion)

    • unexpectedFileSize

      public static Throwable unexpectedFileSize(org.apache.hadoop.fs.Path dfsFile, File localFile, long expectedSize, long localFileSize)

    • unexpectedStateStoreVersion

      public static Throwable unexpectedStateStoreVersion(long version)

    • invalidChangeLogReaderVersion

      public static Throwable invalidChangeLogReaderVersion(long version)

    • invalidChangeLogWriterVersion

      public static Throwable invalidChangeLogWriterVersion(long version)

    • notEnoughMemoryToLoadStore

      public static Throwable notEnoughMemoryToLoadStore(String stateStoreId, String stateStoreProviderName, Throwable e)

    • cannotLoadStore

      public static Throwable cannotLoadStore(Throwable e)

    • hllInvalidLgK

      public static Throwable hllInvalidLgK(String function, int min, int max, int 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()

    • raiseError

      public static RuntimeException raiseError(org.apache.spark.unsafe.types.UTF8String errorClass, org.apache.spark.sql.catalyst.util.MapData errorParms)

    • bitPositionRangeError

      public static Throwable bitPositionRangeError(String funcName, int pos, int size)

    • variantSizeLimitError

      public static Throwable variantSizeLimitError(int sizeLimit, String functionName)

    • invalidVariantCast

      public static Throwable invalidVariantCast(String value, DataType dataType)

    • invalidVariantGetPath

      public static Throwable invalidVariantGetPath(String path, String functionName)

    • malformedVariant

      public static Throwable malformedVariant()

    • invalidCharsetError

      public static RuntimeException invalidCharsetError(String functionName, String charset)

    • malformedCharacterCoding

      public static RuntimeException malformedCharacterCoding(String functionName, String charset)

    • invalidWriterCommitMessageError

      public static Throwable invalidWriterCommitMessageError(String details)

    • codecNotAvailableError

      public static Throwable codecNotAvailableError(String codecName, String availableCodecs)

    • partitionNumMismatchError

      public static org.apache.spark.SparkIllegalArgumentException partitionNumMismatchError(int numFields, int schemaLen)

    • emittedRowsAreOlderThanWatermark

      public static org.apache.spark.SparkRuntimeException emittedRowsAreOlderThanWatermark(long currentWatermark, long emittedRowEventTime)

    • notNullAssertViolation

      public static org.apache.spark.SparkRuntimeException notNullAssertViolation(String walkedTypePath)

    • invalidDatetimeUnitError

      public static Throwable invalidDatetimeUnitError(String functionName, String invalidValue)

    • unsupportedStreamingOperatorWithoutWatermark

      public static AnalysisException unsupportedStreamingOperatorWithoutWatermark(String outputMode, String statefulOperator)

    • conflictingPartitionColumnNamesError

      public static org.apache.spark.SparkRuntimeException conflictingPartitionColumnNamesError(scala.collection.immutable.Seq<String> distinctPartColLists, scala.collection.immutable.Seq<org.apache.hadoop.fs.Path> suspiciousPaths)

    • toSQLId

      public static String toSQLId(String parts)

    • toSQLId

      public static String toSQLId(scala.collection.immutable.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(QueryContext sqlContext)

    • getQueryContext

      public static QueryContext[] getQueryContext(QueryContext context)

    • toDSOption

      public static String toDSOption(String option)

    • toSQLConfVal

      public static String toSQLConfVal(String conf)

    • toSQLExpr

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

    • toSQLValue

      public static String toSQLValue(Object v, DataType t)

    • ordinalNumber

      public static String ordinalNumber(int i)

    • 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)

    • stateStoreHandleNotInitialized

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

    • 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, QueryContext context)

    • invalidInputInCastToDatetimeError

      public static org.apache.spark.SparkDateTimeException invalidInputInCastToDatetimeError(double value, DataType to, QueryContext context)

    • arithmeticOverflowError$default$2

      public static String arithmeticOverflowError$default$2()

    • arithmeticOverflowError$default$3

      public static QueryContext 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.immutable.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)

    • cannotUseKryoSerialization

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

    • elementsOfTupleExceedLimitError

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