QueryCompilationErrors (Spark 3.2.2 JavaDoc)

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

```
public class QueryCompilationErrors
extends Object
```
Object for grouping error messages from exceptions thrown during query compilation. As commands are executed eagerly, this also includes errors thrown during the execution of commands, which users can see immediately.

Constructor Summary

Constructors
Constructor and Description

QueryCompilationErrors()

Constructors
Constructor and Description
`QueryCompilationErrors()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Throwable`	`actionNotAllowedOnTableSincePartitionMetadataNotStoredError(String action, String tableName)`
`static Throwable`	`actionNotAllowedOnTableWithFilesourcePartitionManagementDisabledError(String action, String tableName)`
`static Throwable`	`addColumnWithV1TableCannotSpecifyNotNullError()`
`static Throwable`	`aggregateExpressionRequiredForPivotError(String sql)`
`static Throwable`	`aggregationFunctionAppliedOnNonNumericColumnError(String colName)`
`static Throwable`	`aggregationFunctionAppliedOnNonNumericColumnError(String pivotColumn, int maxValues)`
`static Throwable`	`aliasesNumberNotMatchUDTFOutputError(int aliasesSize, String aliasesNames)`
`static Throwable`	`aliasNumberNotMatchColumnNumberError(int columnSize, int outputSize, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`alterAddColNotSupportDatasourceTableError(Object tableType, org.apache.spark.sql.catalyst.TableIdentifier table)`
`static Throwable`	`alterAddColNotSupportViewError(org.apache.spark.sql.catalyst.TableIdentifier table)`
`static Throwable`	`alterColumnCannotFindColumnInV1TableError(String colName, org.apache.spark.sql.connector.catalog.V1Table v1Table)`
`static Throwable`	`alterColumnWithV1TableCannotSpecifyNotNullError()`
`static Throwable`	`alterDatabaseLocationUnsupportedError(String version)`
`static Throwable`	`alterOnlySupportedWithV2TableError()`
`static Throwable`	`alterQualifiedColumnOnlySupportedWithV2TableError()`
`static Throwable`	`alterTableChangeColumnNotSupportedForColumnTypeError(StructField originColumn, StructField newColumn)`
`static Throwable`	`alterTableRecoverPartitionsNotSupportedForV2TablesError()`
`static Throwable`	`alterTableSerDePropertiesNotSupportedForV2TablesError()`
`static Throwable`	`alterTableSetSerdeForSpecificPartitionNotSupportedError()`
`static Throwable`	`alterTableSetSerdeNotSupportedError()`
`static Throwable`	`alterV2TableSetLocationWithPartitionNotSupportedError()`
`static Throwable`	`ambiguousAttributesInSelfJoinError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.AttributeReference> ambiguousAttrs)`
`static Throwable`	`ambiguousFieldNameError(scala.collection.Seq<String> fieldName, int numMatches, org.apache.spark.sql.catalyst.trees.Origin context)`
`static Throwable`	`ambiguousReferenceToFieldsError(String fields)`
`static Throwable`	`ambiguousRelationAliasNameInNestedCTEError(String name)`
`static Throwable`	`analyzeTableNotSupportedForV2TablesError()`
`static Throwable`	`analyzeTableNotSupportedOnViewsError()`
`static Throwable`	`analyzingColumnStatisticsNotSupportedForColumnTypeError(String name, DataType dataType)`
`static Throwable`	`arrayComponentTypeUnsupportedError(Class<?> clz)`
`static Throwable`	`attributeNameSyntaxError(String name)`
`static Throwable`	`attributeNotFoundError(String colName, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan child)`
`static Throwable`	`batchWriteCapabilityError(Table table, String v2WriteClassName, String v1WriteClassName)`
`static Throwable`	`bucketByAndSortByUnsupportedByOperationError(String operation)`
`static Throwable`	`bucketByUnsupportedByOperationError(String operation)`
`static Throwable`	`bucketingColumnCannotBePartOfPartitionColumnsError(String bucketCol, scala.collection.Seq<String> normalizedPartCols)`
`static Throwable`	`bucketSortingColumnCannotBePartOfPartitionColumnsError(String sortCol, scala.collection.Seq<String> normalizedPartCols)`
`static Throwable`	`cannotAlterTableWithAlterViewError()`
`static Throwable`	`cannotAlterViewWithAlterTableError()`
`static Throwable`	`cannotApplyTableValuedFunctionError(String name, String arguments, String usage, String details)`
`static Throwable`	`cannotConvertBucketWithSortColumnsToTransformError(org.apache.spark.sql.catalyst.catalog.BucketSpec spec)`
`static Throwable`	`cannotConvertDataTypeToParquetTypeError(StructField field)`
`static Throwable`	`cannotConvertTransformsToPartitionColumnsError(scala.collection.Seq<Transform> nonIdTransforms)`
`static Throwable`	`cannotCreateDatabaseWithSameNameAsPreservedDatabaseError(String database)`
`static Throwable`	`cannotCreateJDBCNamespaceUsingProviderError()`
`static Throwable`	`cannotCreateJDBCNamespaceWithPropertyError(String k)`
`static Throwable`	`cannotCreateJDBCTableUsingLocationError()`
`static Throwable`	`cannotCreateJDBCTableUsingProviderError()`
`static Throwable`	`cannotCreateTableWithBothProviderAndSerdeError(scala.Option<String> provider, scala.Option<org.apache.spark.sql.catalyst.plans.logical.SerdeInfo> maybeSerdeInfo)`
`static Throwable`	`cannotCreateTempViewUsingHiveDataSourceError()`
`static Throwable`	`cannotDeleteTableWhereFiltersError(Table table, Filter[] filters)`
`static Throwable`	`cannotDropDefaultDatabaseError()`
`static Throwable`	`cannotDropNativeFuncError(String functionName)`
`static Throwable`	`cannotDropViewWithDropTableError()`
`static Throwable`	`cannotFindCatalogToHandleIdentifierError(String quote)`
`static Throwable`	`cannotFindColumnError(String name, String[] fieldNames)`
`static Throwable`	`cannotFindColumnInRelationOutputError(String colName, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan relation)`
`static Throwable`	`cannotFindPartitionColumnInPartitionSchemaError(StructField readField, StructType partitionSchema)`
`static Throwable`	`cannotLoadClassNotOnClassPathError(String className)`
`static Throwable`	`cannotLoadClassWhenRegisteringFunctionError(String className, org.apache.spark.sql.catalyst.FunctionIdentifier func)`
`static Throwable`	`cannotModifyValueOfSparkConfigError(String key)`
`static Throwable`	`cannotModifyValueOfStaticConfigError(String key)`
`static Throwable`	`cannotOperateManagedTableWithExistingLocationError(String methodName, org.apache.spark.sql.catalyst.TableIdentifier tableIdentifier, org.apache.hadoop.fs.Path tableLocation)`
`static Throwable`	`cannotOperateOnHiveDataSourceFilesError(String operation)`
`static Throwable`	`cannotOverwritePathBeingReadFromError()`
`static Throwable`	`cannotOverwriteTableThatIsBeingReadFromError(String tableName)`
`static Throwable`	`cannotParseIntervalError(String delayThreshold, Throwable e)`
`static Throwable`	`cannotPartitionByNestedColumnError(NamedReference reference)`
`static Throwable`	`cannotPassTypedColumnInUntypedSelectError(String typedCol)`
`static Throwable`	`cannotReadCorruptedTablePropertyError(String key, String details)`
`static Throwable`	`cannotRefreshBuiltInFuncError(String functionName)`
`static Throwable`	`cannotRefreshTempFuncError(String functionName)`
`static Throwable`	`cannotRenameTableWithAlterViewError()`
`static Throwable`	`cannotRenameTempViewToExistingTableError(org.apache.spark.sql.catalyst.TableIdentifier oldName, org.apache.spark.sql.catalyst.TableIdentifier newName)`
`static Throwable`	`cannotRenameTempViewWithDatabaseSpecifiedError(org.apache.spark.sql.catalyst.TableIdentifier oldName, org.apache.spark.sql.catalyst.TableIdentifier newName)`
`static Throwable`	`cannotReplaceMissingTableError(Identifier tableIdentifier)`
`static Throwable`	`cannotReplaceMissingTableError(Identifier tableIdentifier, scala.Option<Throwable> cause)`
`static Throwable`	`cannotResolveAttributeError(String name, String outputStr)`
`static Throwable`	`cannotResolveColumnGivenInputColumnsError(String col, String inputColumns)`
`static Throwable`	`cannotResolveColumnNameAmongAttributesError(String colName, String fieldNames)`
`static AnalysisException`	`cannotResolveColumnNameAmongFieldsError(String colName, String fieldsStr, String extraMsg)`
`static Throwable`	`cannotResolveStarExpandGivenInputColumnsError(String targetString, String columns)`
`static Throwable`	`cannotResolveUserSpecifiedColumnsError(String col, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`cannotRetrieveTableOrViewNotInSameDatabaseError(scala.collection.Seq<org.apache.spark.sql.catalyst.QualifiedTableName> qualifiedTableNames)`
`static Throwable`	`cannotSaveIntervalIntoExternalStorageError()`
`static Throwable`	`cannotSetJDBCNamespaceWithPropertyError(String k)`
`static Throwable`	`cannotSpecifyDatabaseForTempViewError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)`
`static Throwable`	`cannotSpecifyWindowFrameError(String prettyName)`
`static Throwable`	`cannotTranslateExpressionToSourceFilterError(org.apache.spark.sql.catalyst.expressions.Expression f)`
`static Throwable`	`cannotUnsetJDBCNamespaceWithPropertyError(String k)`
`static Throwable`	`cannotUpCastAsAttributeError(org.apache.spark.sql.catalyst.expressions.Attribute fromAttr, org.apache.spark.sql.catalyst.expressions.Attribute toAttr)`
`static Throwable`	`cannotUseAllColumnsForPartitionColumnsError()`
`static Throwable`	`cannotUseCatalogError(CatalogPlugin plugin, String msg)`
`static Throwable`	`cannotUseDataTypeForPartitionColumnError(StructField field)`
`static Throwable`	`cannotUseIntervalTypeInTableSchemaError()`
`static Throwable`	`cannotUseMixtureOfAggFunctionAndGroupAggPandasUDFError()`
`static Throwable`	`cannotUsePreservedDatabaseAsCurrentDatabaseError(String database)`
`static Throwable`	`cannotWriteDataToRelationsWithMultiplePathsError()`
`static Throwable`	`cannotWriteIncompatibleDataToTableError(String tableName, scala.collection.Seq<String> errors)`
`static Throwable`	`cannotWriteNotEnoughColumnsToTableError(String tableName, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> expected, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)`
`static Throwable`	`cannotWriteTooManyColumnsToTableError(String tableName, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> expected, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)`
`static Throwable`	`charOrVarcharTypeAsStringUnsupportedError()`
`static Throwable`	`checkpointLocationNotSpecifiedError()`
`static Throwable`	`classDoesNotImplementUserDefinedAggregateFunctionError(String className)`
`static Throwable`	`classWithoutPublicNonArgumentConstructorError(String className)`
`static Throwable`	`cmdOnlyWorksOnPartitionedTablesError(String cmd, String tableIdentWithDB)`
`static Throwable`	`cmdOnlyWorksOnTableWithLocationError(String cmd, String tableIdentWithDB)`
`static Throwable`	`columnDoesNotExistError(String colName)`
`static Throwable`	`columnNameContainsInvalidCharactersError(String name)`
`static Throwable`	`columnNotDefinedInTableError(String colType, String colName, String tableName, scala.collection.Seq<String> tableCols)`
`static Throwable`	`columnNotFoundInExistingColumnsError(String columnType, String columnName, scala.collection.Seq<String> validColumnNames)`
`static Throwable`	`columnNotFoundInSchemaError(StructField col, scala.Option<StructType> tableSchema)`
`static Throwable`	`columnStatisticsDeserializationNotSupportedError(String name, DataType dataType)`
`static Throwable`	`columnStatisticsSerializationNotSupportedError(String colName, DataType dataType)`
`static Throwable`	`columnTypeNotSupportStatisticsCollectionError(String name, org.apache.spark.sql.catalyst.TableIdentifier tableIdent, DataType dataType)`
`static Throwable`	`commandExecutionInRunnerUnsupportedError(String runner)`
`static Throwable`	`commandNotSupportNestedColumnError(String command, String quoted)`
`static Throwable`	`commandUnsupportedInV2TableError(String name)`
`static Throwable`	`configRemovedInVersionError(String configName, String version, String comment)`
`static Throwable`	`conflictingAttributesInJoinConditionError(org.apache.spark.sql.catalyst.expressions.AttributeSet conflictingAttrs, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan outerPlan, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan subplan)`
`static Throwable`	`corruptedTableNameContextInCatalogError(int numParts, int index)`
`static Throwable`	`corruptedViewQueryOutputColumnsInCatalogError(String numCols, int index)`
`static Throwable`	`corruptedViewReferredTempFunctionsInCatalogError(Exception e)`
`static Throwable`	`corruptedViewReferredTempViewInCatalogError(Exception e)`
`static Throwable`	`corruptedViewSQLConfigsInCatalogError(Exception e)`
`static Throwable`	`createExternalTableWithoutLocationError()`
`static Throwable`	`createFuncWithBothIfNotExistsAndReplaceError()`
`static Throwable`	`createPersistedViewFromDatasetAPINotAllowedError()`
`static Throwable`	`createTableAsSelectWithNonEmptyDirectoryError(String tablePath)`
`static Throwable`	`createTableColumnTypesOptionColumnNotFoundInSchemaError(String col, StructType schema)`
`static Throwable`	`createViewNumColumnsMismatchUserSpecifiedColumnLengthError(int analyzedPlanLength, int userSpecifiedColumnsLength)`
`static Throwable`	`createViewWithBothIfNotExistsAndReplaceError()`
`static Throwable`	`databaseDoesNotExistError(String dbName)`
`static Throwable`	`databaseFromV1SessionCatalogNotSpecifiedError()`
`static Throwable`	`databaseNotEmptyError(String db, String details)`
`static Throwable`	`dataPathNotExistError(String path)`
`static Throwable`	`dataSchemaNotSpecifiedError(String format)`
`static Throwable`	`dataSchemaNotSpecifiedError(String format, String fileCatalog)`
`static Throwable`	`dataSourceOutputModeUnsupportedError(String className, OutputMode outputMode)`
`static Throwable`	`dataTypeMismatchForDeserializerError(DataType dataType, String desiredType)`
`static Throwable`	`dataTypeUnsupportedByClassError(DataType x, String className)`
`static Throwable`	`dataTypeUnsupportedByDataSourceError(String format, StructField field)`
`static Throwable`	`dataTypeUnsupportedByExtractValueError(DataType dataType, org.apache.spark.sql.catalyst.expressions.Expression extraction, org.apache.spark.sql.catalyst.expressions.Expression child)`
`static Throwable`	`ddlWithoutHiveSupportEnabledError(String detail)`
`static Throwable`	`decimalCannotGreaterThanPrecisionError(int scale, int precision)`
`static Throwable`	`decimalOnlySupportPrecisionUptoError(String decimalType, int precision)`
`static Throwable`	`defineTempFuncWithIfNotExistsError()`
`static Throwable`	`defineTempViewWithIfNotExistsError()`
`static Throwable`	`deleteOnlySupportedWithV2TablesError()`
`static Throwable`	`descPartitionNotAllowedOnTempView(String table)`
`static Throwable`	`descPartitionNotAllowedOnView(String table)`
`static Throwable`	`descPartitionNotAllowedOnViewError(String table)`
`static Throwable`	`describeDoesNotSupportPartitionForV2TablesError()`
`static Throwable`	`dropColumnOnlySupportedWithV2TableError()`
`static Throwable`	`dropNonExistentColumnsNotSupportedError(scala.collection.Seq<String> nonExistentColumnNames)`
`static Throwable`	`emptyMultipartIdentifierError()`
`static Throwable`	`emptyWindowExpressionError(org.apache.spark.sql.catalyst.plans.logical.Window expr)`
`static Throwable`	`expectTableNotViewError(org.apache.spark.sql.catalyst.analysis.ResolvedView v, String cmd, scala.Option<String> mismatchHint, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`expectTableOrPermanentViewNotTempViewError(String quoted, String cmd, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`expectViewNotTableError(org.apache.spark.sql.catalyst.analysis.ResolvedTable v, String cmd, scala.Option<String> mismatchHint, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`expressionWithMultiWindowExpressionsError(org.apache.spark.sql.catalyst.expressions.NamedExpression expr, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.WindowSpecDefinition> distinctWindowSpec)`
`static Throwable`	`expressionWithoutWindowExpressionError(org.apache.spark.sql.catalyst.expressions.NamedExpression expr)`
`static Throwable`	`externalCatalogNotSupportShowViewsError(org.apache.spark.sql.catalyst.analysis.ResolvedNamespace resolved)`
`static Throwable`	`failedFallbackParsingError(String msg, Throwable e1, Throwable e2)`
`static Throwable`	`failedToFindAvroDataSourceError(String provider)`
`static Throwable`	`failedToFindKafkaDataSourceError(String provider)`
`static Throwable`	`failedToRebuildExpressionError(Filter filter)`
`static Throwable`	`failToResolveDataSourceForTableError(org.apache.spark.sql.catalyst.catalog.CatalogTable table, String key)`
`static Throwable`	`failToTruncateTableWhenRemovingDataError(String tableIdentWithDB, org.apache.hadoop.fs.Path path, Throwable e)`
`static Throwable`	`fieldNumberMismatchForDeserializerError(StructType schema, int maxOrdinal)`
`static Throwable`	`findMultipleDataSourceError(String provider, scala.collection.Seq<String> sourceNames)`
`static Throwable`	`foundDifferentWindowFunctionTypeError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.NamedExpression> windowExpressions)`
`static Throwable`	`foundDuplicateColumnError(String colType, scala.collection.Seq<String> duplicateCol)`
`static Throwable`	`functionAcceptsOnlyOneArgumentError(String name)`
`static Throwable`	`functionAlreadyExistsError(org.apache.spark.sql.catalyst.FunctionIdentifier func)`
`static Throwable`	`functionCannotProcessInputError(UnboundFunction unbound, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> arguments, UnsupportedOperationException unsupported)`
`static Throwable`	`functionUndefinedError(org.apache.spark.sql.catalyst.FunctionIdentifier name)`
`static Throwable`	`functionUnsupportedInV2CatalogError()`
`static Throwable`	`functionWithUnsupportedSyntaxError(String prettyName, String syntax)`
`static Throwable`	`generatorNotExpectedError(org.apache.spark.sql.catalyst.FunctionIdentifier name, String classCanonicalName)`
`static Throwable`	`generatorOutsideSelectError(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan)`
`static Throwable`	`groupAggPandasUDFUnsupportedByStreamingAggError()`
`static Throwable`	`groupByPositionRangeError(int index, int size)`
`static Throwable`	`groupByPositionRefersToAggregateFunctionError(int index, org.apache.spark.sql.catalyst.expressions.Expression expr)`
`static Throwable`	`groupingColInvalidError(org.apache.spark.sql.catalyst.expressions.Expression groupingCol, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> groupByExprs)`
`static Throwable`	`groupingIDMismatchError(org.apache.spark.sql.catalyst.expressions.GroupingID groupingID, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> groupByExprs)`
`static Throwable`	`groupingMustWithGroupingSetsOrCubeOrRollupError()`
`static Throwable`	`groupingSizeTooLargeError(int sizeLimit)`
`static Throwable`	`hiveCreatePermanentFunctionsUnsupportedError()`
`static Throwable`	`hiveTableTypeUnsupportedError(String tableType)`
`static Throwable`	`hostOptionNotSetError()`
`static Throwable`	`identifierHavingMoreThanTwoNamePartsError(String quoted, String identifier)`
`static Throwable`	`illegalParquetTypeError(String parquetType)`
`static Throwable`	`incompatibleRangeInputDataTypeError(org.apache.spark.sql.catalyst.expressions.Expression expression, DataType dataType)`
`static Throwable`	`incompatibleViewSchemaChange(String viewName, String colName, int expectedNum, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> actualCols, scala.Option<String> viewDDL)`
`static Throwable`	`inputSourceDiffersFromDataSourceProviderError(String source, String tableName, org.apache.spark.sql.catalyst.catalog.CatalogTable table)`
`static Throwable`	`insertIntoViewNotAllowedError(org.apache.spark.sql.catalyst.TableIdentifier identifier, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`insertMismatchedColumnNumberError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> targetAttributes, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> sourceAttributes, int staticPartitionsSize)`
`static Throwable`	`insertMismatchedPartitionNumberError(StructType targetPartitionSchema, int providedPartitionsSize)`
`static Throwable`	`invalidBoundaryEndError(long end)`
`static Throwable`	`invalidBoundaryStartError(long start)`
`static Throwable`	`invalidBucketNumberError(int bucketingMaxBuckets, int numBuckets)`
`static Throwable`	`invalidBucketsNumberError(String numBuckets, String e)`
`static Throwable`	`invalidCoalesceHintParameterError(String hintName)`
`static Throwable`	`invalidDatabaseNameError(String quoted)`
`static Throwable`	`invalidDataSourceError(String className)`
`static Throwable`	`invalidDayTimeField(byte field)`
`static Throwable`	`invalidDayTimeIntervalType(String startFieldName, String endFieldName)`
`static Throwable`	`invalidFieldName(scala.collection.Seq<String> fieldName, scala.collection.Seq<String> path, org.apache.spark.sql.catalyst.trees.Origin context)`
`static Throwable`	`invalidFieldTypeForCorruptRecordError()`
`static Throwable`	`invalidFileFormatForStoredAsError(org.apache.spark.sql.catalyst.plans.logical.SerdeInfo serdeInfo)`
`static Throwable`	`invalidFunctionArgumentNumberError(scala.collection.Seq<Object> validParametersCount, String name, scala.collection.Seq<Class<org.apache.spark.sql.catalyst.expressions.Expression>> params)`
`static Throwable`	`invalidFunctionArgumentsError(String name, String expectedInfo, int actualNumber)`
`static Throwable`	`invalidHintParameterError(String hintName, scala.collection.Seq<Object> invalidParams)`
`static Throwable`	`invalidIncludeTimestampValueError()`
`static Throwable`	`invalidJoinTypeInJoinWithError(org.apache.spark.sql.catalyst.plans.JoinType joinType)`
`static Throwable`	`invalidLiteralForWindowDurationError()`
`static Throwable`	`invalidNameForTableOrDatabaseError(String name)`
`static Throwable`	`invalidOrderingForConstantValuePartitionColumnError(StructType targetPartitionSchema)`
`static Throwable`	`invalidPartitionColumnError(String partKey, StructType targetPartitionSchema)`
`static Throwable`	`invalidPartitionColumnKeyInTableError(String key, String tblName)`
`static Throwable`	`invalidPartitionColumnTypeError(StructField column)`
`static Throwable`	`invalidPartitionSpecError(String details)`
`static Throwable`	`invalidPartitionSpecError(String specKeys, scala.collection.Seq<String> partitionColumnNames, String tableName)`
`static Throwable`	`invalidPartitionTransformationError(org.apache.spark.sql.catalyst.expressions.Expression expr)`
`static Throwable`	`invalidPatternError(String pattern, String message)`
`static Throwable`	`invalidRepartitionExpressionsError(scala.collection.Seq<Object> sortOrders)`
`static Throwable`	`invalidSchemaStringError(org.apache.spark.sql.catalyst.expressions.Expression exp)`
`static Throwable`	`invalidStarUsageError(String prettyName)`
`static Throwable`	`invalidTimestampProvidedForStrategyError(String strategy, String timeString)`
`static Throwable`	`invalidViewNameError(String viewName)`
`static Throwable`	`invalidYearMonthField(byte field)`
`static Throwable`	`invalidYearMonthIntervalType(String startFieldName, String endFieldName)`
`static Throwable`	`joinConditionMissingOrTrivialError(org.apache.spark.sql.catalyst.plans.logical.Join join, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan left, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan right)`
`static Throwable`	`joinStrategyHintParameterNotSupportedError(Object unsupported)`
`static Throwable`	`keyValueInMapNotStringError(org.apache.spark.sql.catalyst.expressions.CreateMap m)`
`static Throwable`	`legacyStoreAssignmentPolicyError()`
`static Throwable`	`literalTypeUnsupportedForSourceTypeError(String field, org.apache.spark.sql.catalyst.expressions.Expression source)`
`static Throwable`	`loadDataInputPathNotExistError(String path)`
`static Throwable`	`loadDataNotSupportedForDatasourceTablesError(String tableIdentWithDB)`
`static Throwable`	`loadDataNotSupportedForV2TablesError()`
`static Throwable`	`loadDataPartitionSizeNotMatchNumPartitionColumnsError(String tableIdentWithDB, int partitionSize, int targetTableSize)`
`static Throwable`	`loadDataTargetTableNotPartitionedButPartitionSpecWasProvidedError(String tableIdentWithDB)`
`static Throwable`	`loadDataWithoutPartitionSpecProvidedError(String tableIdentWithDB)`
`static Throwable`	`logicalPlanForViewNotAnalyzedError()`
`static Throwable`	`lookupFunctionInNonFunctionCatalogError(Identifier ident, CatalogPlugin catalog)`
`static Throwable`	`mismatchedInsertedDataColumnNumberError(String tableName, org.apache.spark.sql.catalyst.plans.logical.InsertIntoStatement insert, scala.collection.immutable.Set<String> staticPartCols)`
`static Throwable`	`mismatchedTableBucketingError(String tableName, String specifiedBucketString, String existingBucketString)`
`static Throwable`	`mismatchedTableColumnNumberError(String tableName, org.apache.spark.sql.catalyst.catalog.CatalogTable existingTable, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)`
`static Throwable`	`mismatchedTableFormatError(String tableName, Class<?> existingProvider, Class<?> specifiedProvider)`
`static Throwable`	`mismatchedTableLocationError(org.apache.spark.sql.catalyst.TableIdentifier identifier, org.apache.spark.sql.catalyst.catalog.CatalogTable existingTable, org.apache.spark.sql.catalyst.catalog.CatalogTable tableDesc)`
`static Throwable`	`mismatchedTablePartitionColumnError(String tableName, scala.collection.Seq<String> specifiedPartCols, String existingPartCols)`
`static Throwable`	`missingFieldError(scala.collection.Seq<String> fieldName, org.apache.spark.sql.catalyst.analysis.ResolvedTable table, org.apache.spark.sql.catalyst.trees.Origin context)`
`static Throwable`	`missingStaticPartitionColumn(String staticName)`
`static Throwable`	`mixedRefsInAggFunc(String funcStr)`
`static Throwable`	`moreThanOneGeneratorError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> generators, String clause)`
`static Throwable`	`multiplePartitionColumnValuesSpecifiedError(StructField field, scala.collection.immutable.Map<String,String> potentialSpecs)`
`static Throwable`	`multiTimeWindowExpressionsNotSupportedError(org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`namespaceAlreadyExistsError(String[] namespace)`
`static Throwable`	`negativeScaleNotAllowedError(int scale)`
`static Throwable`	`nestedDatabaseUnsupportedByV1SessionCatalogError(String catalog)`
`static Throwable`	`nestedGeneratorError(org.apache.spark.sql.catalyst.expressions.Expression trimmedNestedGenerator)`
`static Throwable`	`noHandlerForUDAFError(String name)`
`static Throwable`	`nonDeterministicFilterInAggregateError()`
`static Throwable`	`nonLiteralPivotValError(org.apache.spark.sql.catalyst.expressions.Expression pivotVal)`
`static Throwable`	`nonMapFunctionNotAllowedError()`
`static Throwable`	`nonPartitionColError(String partitionName)`
`static Throwable`	`nonPartitionPruningPredicatesNotExpectedError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> nonPartitionPruningPredicates)`
`static Throwable`	`noSuchFunctionError(org.apache.spark.sql.catalyst.FunctionIdentifier identifier)`
`static Throwable`	`noSuchNamespaceError(String[] namespace)`
`static Throwable`	`noSuchPartitionError(String db, String table, scala.collection.immutable.Map<String,String> partition)`
`static Throwable`	`noSuchStructFieldInGivenFieldsError(String fieldName, StructField[] fields)`
`static Throwable`	`noSuchTableError(Identifier ident)`
`static Throwable`	`noSuchTableError(String db, String table)`
`static Throwable`	`notAllowedToAddDBPrefixForTempViewError(String database)`
`static Throwable`	`notAllowedToCreatePermanentViewByReferencingTempFuncError(org.apache.spark.sql.catalyst.TableIdentifier name, String funcName)`
`static Throwable`	`notAllowedToCreatePermanentViewByReferencingTempViewError(org.apache.spark.sql.catalyst.TableIdentifier name, String nameParts)`
`static Throwable`	`notAllowedToCreatePermanentViewWithoutAssigningAliasForExpressionError(org.apache.spark.sql.catalyst.TableIdentifier name, String attrName)`
`static Throwable`	`numberOfPartitionsNotAllowedWithUnspecifiedDistributionError()`
`static Throwable`	`operationNotSupportPartitioningError(String operation)`
`static Throwable`	`orcNotUsedWithHiveEnabledError()`
`static Throwable`	`orderByPositionRangeError(int index, int size, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`outerScopeFailureForNewInstanceError(String className)`
`static Throwable`	`outputPathAlreadyExistsError(org.apache.hadoop.fs.Path outputPath)`
`static Throwable`	`pandasUDFAggregateNotSupportedInPivotError()`
`static Throwable`	`parquetTypeUnsupportedYetError(String parquetType)`
`static Throwable`	`parseModeUnsupportedError(String funcName, org.apache.spark.sql.catalyst.util.ParseMode mode)`
`static Throwable`	`partitionByDoesNotAllowedWhenUsingInsertIntoError()`
`static Throwable`	`partitionColumnNotFoundInSchemaError(String col, String schemaCatalog)`
`static Throwable`	`partitionColumnNotSpecifiedError(String format, String partitionColumn)`
`static Throwable`	`partitionNotSpecifyLocationUriError(String specString)`
`static Throwable`	`pathOptionNotSetCorrectlyWhenReadingError()`
`static Throwable`	`pathOptionNotSetCorrectlyWhenWritingError()`
`static Throwable`	`permanentViewNotSupportedByStreamingReadingAPIError(String quoted)`
`static Throwable`	`pivotValDataTypeMismatchError(org.apache.spark.sql.catalyst.expressions.Expression pivotVal, org.apache.spark.sql.catalyst.expressions.Expression pivotCol)`
`static Throwable`	`portOptionNotSetError()`
`static Throwable`	`queryFromRawFilesIncludeCorruptRecordColumnError()`
`static Throwable`	`queryNameNotSpecifiedForMemorySinkError()`
`static Throwable`	`readNonStreamingTempViewError(String quoted)`
`static Throwable`	`recoverQueryFromCheckpointUnsupportedError(org.apache.hadoop.fs.Path checkpointPath)`
`static Throwable`	`recursiveViewDetectedError(org.apache.spark.sql.catalyst.TableIdentifier viewIdent, scala.collection.Seq<org.apache.spark.sql.catalyst.TableIdentifier> newPath)`
`static Throwable`	`referenceColNotFoundForAlterTableChangesError(TableChange.After after, String parentName)`
`static Throwable`	`renameColumnOnlySupportedWithV2TableError()`
`static Throwable`	`renameTableSourceAndDestinationMismatchError(String db, String newDb)`
`static Throwable`	`renameTempViewToExistingViewError(String oldName, String newName)`
`static Throwable`	`repairTableNotSupportedForV2TablesError()`
`static Throwable`	`replaceColumnsOnlySupportedWithV2TableError()`
`static Throwable`	`replaceTableAsSelectOnlySupportedWithV2TableError()`
`static Throwable`	`replaceTableOnlySupportedWithV2TableError()`
`static Throwable`	`requestedPartitionsMismatchTablePartitionsError(String tableName, scala.collection.immutable.Map<String,scala.Option<String>> normalizedPartSpec, StructType partColNames)`
`static Throwable`	`requiresSinglePartNamespaceError(scala.collection.Seq<String> ns)`
`static Throwable`	`resourceTypeNotSupportedError(String resourceType)`
`static Throwable`	`saveDataIntoViewNotAllowedError()`
`static Throwable`	`schemaIsNotStructTypeError(DataType dataType)`
`static Throwable`	`schemaNotFoldableError(org.apache.spark.sql.catalyst.expressions.Expression exp)`
`static Throwable`	`schemaNotSpecifiedForSchemaRelationProviderError(String className)`
`static Throwable`	`secondArgumentInFunctionIsNotBooleanLiteralError(String funcName)`
`static Throwable`	`secondArgumentNotDoubleLiteralError()`
`static Throwable`	`secondArgumentOfFunctionIsNotIntegerError(String function, NumberFormatException e)`
`static Throwable`	`selectExprNotInGroupByError(org.apache.spark.sql.catalyst.expressions.Expression expr, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Alias> groupByAliases)`
`static Throwable`	`sessionWindowGapDurationDataTypeError(DataType dt)`
`static Throwable`	`setPathOptionAndCallWithPathParameterError(String method)`
`static Throwable`	`showColumnsNotSupportedForV2TablesError()`
`static Throwable`	`showColumnsWithConflictDatabasesError(scala.collection.Seq<String> db, org.apache.spark.sql.catalyst.TableIdentifier v1TableName)`
`static Throwable`	`showCreateTableAsSerdeNotAllowedOnSparkDataSourceTableError(org.apache.spark.sql.catalyst.TableIdentifier table)`
`static Throwable`	`showCreateTableAsSerdeNotSupportedForV2TablesError()`
`static Throwable`	`showCreateTableFailToExecuteUnsupportedConfError(org.apache.spark.sql.catalyst.TableIdentifier table, scala.collection.mutable.StringBuilder builder)`
`static Throwable`	`showCreateTableFailToExecuteUnsupportedFeatureError(org.apache.spark.sql.catalyst.catalog.CatalogTable table)`
`static Throwable`	`showCreateTableNotSupportedOnTempView(String table)`
`static Throwable`	`showCreateTableNotSupportTransactionalHiveTableError(org.apache.spark.sql.catalyst.catalog.CatalogTable table)`
`static Throwable`	`showCreateTableOrViewFailToExecuteUnsupportedFeatureError(org.apache.spark.sql.catalyst.catalog.CatalogTable table, scala.collection.Seq<String> features)`
`static Throwable`	`showPartitionNotAllowedOnTableNotPartitionedError(String tableIdentWithDB)`
`static Throwable`	`singleTableStarInCountNotAllowedError(String targetString)`
`static Throwable`	`sortByNotUsedWithBucketByError()`
`static Throwable`	`sourceNotSupportedWithContinuousTriggerError(String source)`
`static Throwable`	`specifyingDBInCreateTempFuncError(String databaseName)`
`static Throwable`	`specifyingDBInDropTempFuncError(String databaseName)`
`static Throwable`	`specifyPartitionNotAllowedWhenTableSchemaNotDefinedError()`
`static Throwable`	`sqlOnlySupportedWithV1TablesError(String sql)`
`static Throwable`	`starExpandDataTypeNotSupportedError(scala.collection.Seq<String> attributes)`
`static Throwable`	`starNotAllowedWhenGroupByOrdinalPositionUsedError()`
`static Throwable`	`streamingIntoViewNotSupportedError(String viewName)`
`static Throwable`	`streamingSourcesDoNotSupportCommonExecutionModeError(scala.collection.Seq<String> microBatchSources, scala.collection.Seq<String> continuousSources)`
`static Throwable`	`streamJoinStreamWithoutEqualityPredicateUnsupportedError(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan)`
`static Throwable`	`tableAlreadyExistsError(Identifier ident)`
`static Throwable`	`tableAlreadyExistsError(String table, String guide)`
`static Throwable`	`tableAlreadyExistsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)`
`static Throwable`	`tableDoesNotExistInDatabaseError(String tableName, String dbName)`
`static Throwable`	`tableDoesNotSupportAtomicPartitionManagementError(Table table)`
`static Throwable`	`tableDoesNotSupportDeletesError(Table table)`
`static Throwable`	`tableDoesNotSupportPartitionManagementError(Table table)`
`static Throwable`	`tableDoesNotSupportReadsError(Table table)`
`static Throwable`	`tableDoesNotSupportTruncatesError(Table table)`
`static Throwable`	`tableDoesNotSupportWritesError(Table table)`
`static Throwable`	`tableIdentifierExistsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdentifier)`
`static Throwable`	`tableIdentifierNotConvertedToHadoopFsRelationError(org.apache.spark.sql.catalyst.TableIdentifier tableIdentifier)`
`static Throwable`	`tableIsNotViewError(org.apache.spark.sql.catalyst.TableIdentifier name)`
`static Throwable`	`tableNotSpecifyDatabaseError(org.apache.spark.sql.catalyst.TableIdentifier identifier)`
`static Throwable`	`tableNotSpecifyLocationUriError(org.apache.spark.sql.catalyst.TableIdentifier identifier)`
`static Throwable`	`tableNotSupportStreamingWriteError(String tableName, Table t)`
`static Throwable`	`tableOrViewAlreadyExistsError(String name)`
`static Throwable`	`tableOrViewNotFoundError(String table)`
`static Throwable`	`tableOrViewNotFoundInDatabaseError(String tableName, String dbName)`
`static Throwable`	`tempViewNotCachedForAnalyzingColumnsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)`
`static Throwable`	`tempViewNotSupportStreamingWriteError(String viewName)`
`static Throwable`	`textDataSourceWithMultiColumnsError(StructType schema)`
`static Throwable`	`truncateTableOnExternalTablesError(String tableIdentWithDB)`
`static Throwable`	`truncateTablePartitionNotSupportedForNotPartitionedTablesError(String tableIdentWithDB)`
`static Throwable`	`udfClassDoesNotImplementAnyUDFInterfaceError(String className)`
`static Throwable`	`udfClassNotAllowedToImplementMultiUDFInterfacesError(String className)`
`static Throwable`	`udfClassWithTooManyTypeArgumentsError(int n)`
`static Throwable`	`unexpectedEvalTypesForUDFsError(scala.collection.immutable.Set<Object> evalTypes)`
`static Throwable`	`unexpectedPartitionColumnPrefixError(String table, String database, String schemaColumns, String specColumns)`
`static Throwable`	`unexpectedTypeOfRelationError(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan relation, String tableName)`
`static Throwable`	`unfoldableFieldUnsupportedError()`
`static Throwable`	`unknownHiveResourceTypeError(String resourceType)`
`static Throwable`	`unorderablePivotColError(org.apache.spark.sql.catalyst.expressions.Expression pivotCol)`
`static Throwable`	`unrecognizedParquetTypeError(String field)`
`static Throwable`	`unresolvedUsingColForJoinError(String colName, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan, String side)`
`static Throwable`	`unsetNonExistentPropertyError(String property, org.apache.spark.sql.catalyst.TableIdentifier table)`
`static Throwable`	`unsupportedAbstractDataTypeForUpCastError(org.apache.spark.sql.types.AbstractDataType gotType)`
`static Throwable`	`unsupportedAppendInBatchModeError(Table table)`
`static Throwable`	`unsupportedBatchReadError(Table table)`
`static Throwable`	`unsupportedDataSourceTypeForDirectQueryOnFilesError(String className)`
`static Throwable`	`unsupportedDeleteByConditionWithSubqueryError(scala.Option<org.apache.spark.sql.catalyst.expressions.Expression> condition)`
`static Throwable`	`unsupportedDynamicOverwriteInBatchModeError(Table table)`
`static Throwable`	`unsupportedIfNotExistsError(String tableName)`
`static Throwable`	`unsupportedJDBCNamespaceChangeInCatalogError(scala.collection.Seq<NamespaceChange> changes)`
`static Throwable`	`unsupportedMicroBatchOrContinuousScanError(Table table)`
`static Throwable`	`unsupportedOverwriteByFilterInBatchModeError(Table table)`
`static Throwable`	`unsupportedTableChangeInJDBCCatalogError(TableChange change)`
`static Throwable`	`unsupportedTableOperationError(Table table, String cmd)`
`static Throwable`	`unsupportedTruncateInBatchModeError(Table table)`
`static Throwable`	`upCastFailureError(String fromStr, org.apache.spark.sql.catalyst.expressions.Expression from, DataType to, scala.collection.Seq<String> walkedTypePath)`
`static Throwable`	`usePythonUDFInJoinConditionUnsupportedError(org.apache.spark.sql.catalyst.plans.JoinType joinType)`
`static Throwable`	`userDefinedPartitionNotFoundInJDBCRelationError(String columnName, String schema)`
`static Throwable`	`userSpecifiedSchemaMismatchActualSchemaError(StructType schema, StructType actualSchema)`
`static Throwable`	`userSpecifiedSchemaUnsupportedError(String operation)`
`static Throwable`	`usingUntypedScalaUDFError()`
`static Throwable`	`v2FunctionInvalidInputTypeLengthError(BoundFunction bound, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> args)`
`static Throwable`	`viewAlreadyExistsError(org.apache.spark.sql.catalyst.TableIdentifier name)`
`static Throwable`	`viewDepthExceedsMaxResolutionDepthError(org.apache.spark.sql.catalyst.TableIdentifier identifier, int maxNestedViewDepth, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`viewOutputNumberMismatchQueryColumnNamesError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> output, scala.collection.Seq<String> queryColumnNames)`
`static Throwable`	`windowAggregateFunctionWithFilterNotSupportedError()`
`static Throwable`	`windowFrameNotMatchRequiredFrameError(org.apache.spark.sql.catalyst.expressions.SpecifiedWindowFrame f, org.apache.spark.sql.catalyst.expressions.WindowFrame required)`
`static Throwable`	`windowFunctionInsideAggregateFunctionNotAllowedError()`
`static Throwable`	`windowFunctionNotAllowedError(String clauseName)`
`static Throwable`	`windowFunctionWithWindowFrameNotOrderedError(org.apache.spark.sql.catalyst.expressions.WindowFunction wf)`
`static Throwable`	`windowSpecificationNotDefinedError(String windowName)`
`static Throwable`	`writeEmptySchemasUnsupportedByDataSourceError()`
`static Throwable`	`writeIntoTempViewNotAllowedError(String quoted)`
`static Throwable`	`writeIntoV1TableNotAllowedError(org.apache.spark.sql.catalyst.TableIdentifier identifier, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`writeIntoViewNotAllowedError(org.apache.spark.sql.catalyst.TableIdentifier identifier, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`writeTableWithMismatchedColumnsError(int columnSize, int outputSize, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`writeWithSaveModeUnsupportedBySourceError(String source, String createMode)`

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

Constructor Detail
- QueryCompilationErrors
```
public QueryCompilationErrors()
```

Method Detail

groupingIDMismatchError

public static Throwable groupingIDMismatchError(org.apache.spark.sql.catalyst.expressions.GroupingID groupingID,
                                                scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> groupByExprs)

groupingColInvalidError

public static Throwable groupingColInvalidError(org.apache.spark.sql.catalyst.expressions.Expression groupingCol,
                                                scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> groupByExprs)

groupingSizeTooLargeError

public static Throwable groupingSizeTooLargeError(int sizeLimit)

unorderablePivotColError

public static Throwable unorderablePivotColError(org.apache.spark.sql.catalyst.expressions.Expression pivotCol)

nonLiteralPivotValError

public static Throwable nonLiteralPivotValError(org.apache.spark.sql.catalyst.expressions.Expression pivotVal)

pivotValDataTypeMismatchError

public static Throwable pivotValDataTypeMismatchError(org.apache.spark.sql.catalyst.expressions.Expression pivotVal,
                                                      org.apache.spark.sql.catalyst.expressions.Expression pivotCol)

unsupportedIfNotExistsError

public static Throwable unsupportedIfNotExistsError(String tableName)

nonPartitionColError

public static Throwable nonPartitionColError(String partitionName)

missingStaticPartitionColumn

public static Throwable missingStaticPartitionColumn(String staticName)

nestedGeneratorError

public static Throwable nestedGeneratorError(org.apache.spark.sql.catalyst.expressions.Expression trimmedNestedGenerator)

moreThanOneGeneratorError

public static Throwable moreThanOneGeneratorError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> generators,
                                                  String clause)

generatorOutsideSelectError

public static Throwable generatorOutsideSelectError(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan)

legacyStoreAssignmentPolicyError

public static Throwable legacyStoreAssignmentPolicyError()

unresolvedUsingColForJoinError

public static Throwable unresolvedUsingColForJoinError(String colName,
                                                       org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan,
                                                       String side)

dataTypeMismatchForDeserializerError

public static Throwable dataTypeMismatchForDeserializerError(DataType dataType,
                                                             String desiredType)

fieldNumberMismatchForDeserializerError

public static Throwable fieldNumberMismatchForDeserializerError(StructType schema,
                                                                int maxOrdinal)

upCastFailureError

public static Throwable upCastFailureError(String fromStr,
                                           org.apache.spark.sql.catalyst.expressions.Expression from,
                                           DataType to,
                                           scala.collection.Seq<String> walkedTypePath)

unsupportedAbstractDataTypeForUpCastError

public static Throwable unsupportedAbstractDataTypeForUpCastError(org.apache.spark.sql.types.AbstractDataType gotType)

outerScopeFailureForNewInstanceError

public static Throwable outerScopeFailureForNewInstanceError(String className)

referenceColNotFoundForAlterTableChangesError

public static Throwable referenceColNotFoundForAlterTableChangesError(TableChange.After after,
                                                                      String parentName)

windowSpecificationNotDefinedError

public static Throwable windowSpecificationNotDefinedError(String windowName)

selectExprNotInGroupByError

public static Throwable selectExprNotInGroupByError(org.apache.spark.sql.catalyst.expressions.Expression expr,
                                                    scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Alias> groupByAliases)

groupingMustWithGroupingSetsOrCubeOrRollupError

public static Throwable groupingMustWithGroupingSetsOrCubeOrRollupError()

pandasUDFAggregateNotSupportedInPivotError

public static Throwable pandasUDFAggregateNotSupportedInPivotError()

aggregateExpressionRequiredForPivotError

public static Throwable aggregateExpressionRequiredForPivotError(String sql)

writeIntoTempViewNotAllowedError

public static Throwable writeIntoTempViewNotAllowedError(String quoted)

expectTableOrPermanentViewNotTempViewError

public static Throwable expectTableOrPermanentViewNotTempViewError(String quoted,
                                                                   String cmd,
                                                                   org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

readNonStreamingTempViewError

public static Throwable readNonStreamingTempViewError(String quoted)

viewDepthExceedsMaxResolutionDepthError

public static Throwable viewDepthExceedsMaxResolutionDepthError(org.apache.spark.sql.catalyst.TableIdentifier identifier,
                                                                int maxNestedViewDepth,
                                                                org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

insertIntoViewNotAllowedError

public static Throwable insertIntoViewNotAllowedError(org.apache.spark.sql.catalyst.TableIdentifier identifier,
                                                      org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

writeIntoViewNotAllowedError

public static Throwable writeIntoViewNotAllowedError(org.apache.spark.sql.catalyst.TableIdentifier identifier,
                                                     org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

writeIntoV1TableNotAllowedError

public static Throwable writeIntoV1TableNotAllowedError(org.apache.spark.sql.catalyst.TableIdentifier identifier,
                                                        org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

expectTableNotViewError

public static Throwable expectTableNotViewError(org.apache.spark.sql.catalyst.analysis.ResolvedView v,
                                                String cmd,
                                                scala.Option<String> mismatchHint,
                                                org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

expectViewNotTableError

public static Throwable expectViewNotTableError(org.apache.spark.sql.catalyst.analysis.ResolvedTable v,
                                                String cmd,
                                                scala.Option<String> mismatchHint,
                                                org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

permanentViewNotSupportedByStreamingReadingAPIError

public static Throwable permanentViewNotSupportedByStreamingReadingAPIError(String quoted)

starNotAllowedWhenGroupByOrdinalPositionUsedError

public static Throwable starNotAllowedWhenGroupByOrdinalPositionUsedError()

invalidStarUsageError

public static Throwable invalidStarUsageError(String prettyName)

singleTableStarInCountNotAllowedError

public static Throwable singleTableStarInCountNotAllowedError(String targetString)

orderByPositionRangeError

public static Throwable orderByPositionRangeError(int index,
                                                  int size,
                                                  org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

groupByPositionRefersToAggregateFunctionError

public static Throwable groupByPositionRefersToAggregateFunctionError(int index,
                                                                      org.apache.spark.sql.catalyst.expressions.Expression expr)

groupByPositionRangeError

public static Throwable groupByPositionRangeError(int index,
                                                  int size)

generatorNotExpectedError

public static Throwable generatorNotExpectedError(org.apache.spark.sql.catalyst.FunctionIdentifier name,
                                                  String classCanonicalName)

functionWithUnsupportedSyntaxError

public static Throwable functionWithUnsupportedSyntaxError(String prettyName,
                                                           String syntax)

nonDeterministicFilterInAggregateError

public static Throwable nonDeterministicFilterInAggregateError()

aliasNumberNotMatchColumnNumberError

public static Throwable aliasNumberNotMatchColumnNumberError(int columnSize,
                                                             int outputSize,
                                                             org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

aliasesNumberNotMatchUDTFOutputError

public static Throwable aliasesNumberNotMatchUDTFOutputError(int aliasesSize,
                                                             String aliasesNames)

windowAggregateFunctionWithFilterNotSupportedError

public static Throwable windowAggregateFunctionWithFilterNotSupportedError()

windowFunctionInsideAggregateFunctionNotAllowedError

public static Throwable windowFunctionInsideAggregateFunctionNotAllowedError()

expressionWithoutWindowExpressionError

public static Throwable expressionWithoutWindowExpressionError(org.apache.spark.sql.catalyst.expressions.NamedExpression expr)

expressionWithMultiWindowExpressionsError

public static Throwable expressionWithMultiWindowExpressionsError(org.apache.spark.sql.catalyst.expressions.NamedExpression expr,
                                                                  scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.WindowSpecDefinition> distinctWindowSpec)

windowFunctionNotAllowedError

public static Throwable windowFunctionNotAllowedError(String clauseName)

cannotSpecifyWindowFrameError

public static Throwable cannotSpecifyWindowFrameError(String prettyName)

windowFrameNotMatchRequiredFrameError

public static Throwable windowFrameNotMatchRequiredFrameError(org.apache.spark.sql.catalyst.expressions.SpecifiedWindowFrame f,
                                                              org.apache.spark.sql.catalyst.expressions.WindowFrame required)

windowFunctionWithWindowFrameNotOrderedError

public static Throwable windowFunctionWithWindowFrameNotOrderedError(org.apache.spark.sql.catalyst.expressions.WindowFunction wf)

cannotResolveUserSpecifiedColumnsError

public static Throwable cannotResolveUserSpecifiedColumnsError(String col,
                                                               org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

writeTableWithMismatchedColumnsError

public static Throwable writeTableWithMismatchedColumnsError(int columnSize,
                                                             int outputSize,
                                                             org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

multiTimeWindowExpressionsNotSupportedError

public static Throwable multiTimeWindowExpressionsNotSupportedError(org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

sessionWindowGapDurationDataTypeError

public static Throwable sessionWindowGapDurationDataTypeError(DataType dt)

viewOutputNumberMismatchQueryColumnNamesError

public static Throwable viewOutputNumberMismatchQueryColumnNamesError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> output,
                                                                      scala.collection.Seq<String> queryColumnNames)

attributeNotFoundError

public static Throwable attributeNotFoundError(String colName,
                                               org.apache.spark.sql.catalyst.plans.logical.LogicalPlan child)

cannotUpCastAsAttributeError

public static Throwable cannotUpCastAsAttributeError(org.apache.spark.sql.catalyst.expressions.Attribute fromAttr,
                                                     org.apache.spark.sql.catalyst.expressions.Attribute toAttr)

functionUndefinedError

public static Throwable functionUndefinedError(org.apache.spark.sql.catalyst.FunctionIdentifier name)

invalidFunctionArgumentsError

public static Throwable invalidFunctionArgumentsError(String name,
                                                      String expectedInfo,
                                                      int actualNumber)

invalidFunctionArgumentNumberError

public static Throwable invalidFunctionArgumentNumberError(scala.collection.Seq<Object> validParametersCount,
                                                           String name,
                                                           scala.collection.Seq<Class<org.apache.spark.sql.catalyst.expressions.Expression>> params)

functionAcceptsOnlyOneArgumentError

public static Throwable functionAcceptsOnlyOneArgumentError(String name)

alterV2TableSetLocationWithPartitionNotSupportedError

public static Throwable alterV2TableSetLocationWithPartitionNotSupportedError()

joinStrategyHintParameterNotSupportedError

public static Throwable joinStrategyHintParameterNotSupportedError(Object unsupported)

invalidHintParameterError

public static Throwable invalidHintParameterError(String hintName,
                                                  scala.collection.Seq<Object> invalidParams)

invalidCoalesceHintParameterError

public static Throwable invalidCoalesceHintParameterError(String hintName)

attributeNameSyntaxError

public static Throwable attributeNameSyntaxError(String name)

starExpandDataTypeNotSupportedError

public static Throwable starExpandDataTypeNotSupportedError(scala.collection.Seq<String> attributes)

cannotResolveStarExpandGivenInputColumnsError

public static Throwable cannotResolveStarExpandGivenInputColumnsError(String targetString,
                                                                      String columns)

addColumnWithV1TableCannotSpecifyNotNullError

public static Throwable addColumnWithV1TableCannotSpecifyNotNullError()

replaceColumnsOnlySupportedWithV2TableError

public static Throwable replaceColumnsOnlySupportedWithV2TableError()

alterQualifiedColumnOnlySupportedWithV2TableError

public static Throwable alterQualifiedColumnOnlySupportedWithV2TableError()

alterColumnWithV1TableCannotSpecifyNotNullError

public static Throwable alterColumnWithV1TableCannotSpecifyNotNullError()

alterOnlySupportedWithV2TableError

public static Throwable alterOnlySupportedWithV2TableError()

alterColumnCannotFindColumnInV1TableError

public static Throwable alterColumnCannotFindColumnInV1TableError(String colName,
                                                                  org.apache.spark.sql.connector.catalog.V1Table v1Table)

renameColumnOnlySupportedWithV2TableError

public static Throwable renameColumnOnlySupportedWithV2TableError()

dropColumnOnlySupportedWithV2TableError

public static Throwable dropColumnOnlySupportedWithV2TableError()

invalidDatabaseNameError

public static Throwable invalidDatabaseNameError(String quoted)

replaceTableOnlySupportedWithV2TableError

public static Throwable replaceTableOnlySupportedWithV2TableError()

replaceTableAsSelectOnlySupportedWithV2TableError

public static Throwable replaceTableAsSelectOnlySupportedWithV2TableError()

cannotDropViewWithDropTableError

public static Throwable cannotDropViewWithDropTableError()

showColumnsWithConflictDatabasesError

public static Throwable showColumnsWithConflictDatabasesError(scala.collection.Seq<String> db,
                                                              org.apache.spark.sql.catalyst.TableIdentifier v1TableName)

externalCatalogNotSupportShowViewsError

public static Throwable externalCatalogNotSupportShowViewsError(org.apache.spark.sql.catalyst.analysis.ResolvedNamespace resolved)

sqlOnlySupportedWithV1TablesError

public static Throwable sqlOnlySupportedWithV1TablesError(String sql)

cannotCreateTableWithBothProviderAndSerdeError

public static Throwable cannotCreateTableWithBothProviderAndSerdeError(scala.Option<String> provider,
                                                                       scala.Option<org.apache.spark.sql.catalyst.plans.logical.SerdeInfo> maybeSerdeInfo)

invalidFileFormatForStoredAsError

public static Throwable invalidFileFormatForStoredAsError(org.apache.spark.sql.catalyst.plans.logical.SerdeInfo serdeInfo)

commandNotSupportNestedColumnError

public static Throwable commandNotSupportNestedColumnError(String command,
                                                           String quoted)

columnDoesNotExistError

public static Throwable columnDoesNotExistError(String colName)

renameTempViewToExistingViewError

public static Throwable renameTempViewToExistingViewError(String oldName,
                                                          String newName)

databaseNotEmptyError

public static Throwable databaseNotEmptyError(String db,
                                              String details)

invalidNameForTableOrDatabaseError

public static Throwable invalidNameForTableOrDatabaseError(String name)

cannotCreateDatabaseWithSameNameAsPreservedDatabaseError

public static Throwable cannotCreateDatabaseWithSameNameAsPreservedDatabaseError(String database)

cannotDropDefaultDatabaseError

public static Throwable cannotDropDefaultDatabaseError()

cannotUsePreservedDatabaseAsCurrentDatabaseError

public static Throwable cannotUsePreservedDatabaseAsCurrentDatabaseError(String database)

createExternalTableWithoutLocationError

public static Throwable createExternalTableWithoutLocationError()

cannotOperateManagedTableWithExistingLocationError

public static Throwable cannotOperateManagedTableWithExistingLocationError(String methodName,
                                                                           org.apache.spark.sql.catalyst.TableIdentifier tableIdentifier,
                                                                           org.apache.hadoop.fs.Path tableLocation)

dropNonExistentColumnsNotSupportedError

public static Throwable dropNonExistentColumnsNotSupportedError(scala.collection.Seq<String> nonExistentColumnNames)

cannotRetrieveTableOrViewNotInSameDatabaseError

public static Throwable cannotRetrieveTableOrViewNotInSameDatabaseError(scala.collection.Seq<org.apache.spark.sql.catalyst.QualifiedTableName> qualifiedTableNames)

renameTableSourceAndDestinationMismatchError

public static Throwable renameTableSourceAndDestinationMismatchError(String db,
                                                                     String newDb)

cannotRenameTempViewWithDatabaseSpecifiedError

public static Throwable cannotRenameTempViewWithDatabaseSpecifiedError(org.apache.spark.sql.catalyst.TableIdentifier oldName,
                                                                       org.apache.spark.sql.catalyst.TableIdentifier newName)

cannotRenameTempViewToExistingTableError

public static Throwable cannotRenameTempViewToExistingTableError(org.apache.spark.sql.catalyst.TableIdentifier oldName,
                                                                 org.apache.spark.sql.catalyst.TableIdentifier newName)

invalidPartitionSpecError

public static Throwable invalidPartitionSpecError(String details)

functionAlreadyExistsError

public static Throwable functionAlreadyExistsError(org.apache.spark.sql.catalyst.FunctionIdentifier func)

cannotLoadClassWhenRegisteringFunctionError

public static Throwable cannotLoadClassWhenRegisteringFunctionError(String className,
                                                                    org.apache.spark.sql.catalyst.FunctionIdentifier func)

resourceTypeNotSupportedError

public static Throwable resourceTypeNotSupportedError(String resourceType)

tableNotSpecifyDatabaseError

public static Throwable tableNotSpecifyDatabaseError(org.apache.spark.sql.catalyst.TableIdentifier identifier)

tableNotSpecifyLocationUriError

public static Throwable tableNotSpecifyLocationUriError(org.apache.spark.sql.catalyst.TableIdentifier identifier)

partitionNotSpecifyLocationUriError

public static Throwable partitionNotSpecifyLocationUriError(String specString)

invalidBucketNumberError

public static Throwable invalidBucketNumberError(int bucketingMaxBuckets,
                                                 int numBuckets)

corruptedTableNameContextInCatalogError

public static Throwable corruptedTableNameContextInCatalogError(int numParts,
                                                                int index)

corruptedViewSQLConfigsInCatalogError

public static Throwable corruptedViewSQLConfigsInCatalogError(Exception e)

corruptedViewQueryOutputColumnsInCatalogError

public static Throwable corruptedViewQueryOutputColumnsInCatalogError(String numCols,
                                                                      int index)

corruptedViewReferredTempViewInCatalogError

public static Throwable corruptedViewReferredTempViewInCatalogError(Exception e)

corruptedViewReferredTempFunctionsInCatalogError

public static Throwable corruptedViewReferredTempFunctionsInCatalogError(Exception e)

columnStatisticsDeserializationNotSupportedError

public static Throwable columnStatisticsDeserializationNotSupportedError(String name,
                                                                         DataType dataType)

columnStatisticsSerializationNotSupportedError

public static Throwable columnStatisticsSerializationNotSupportedError(String colName,
                                                                       DataType dataType)

cannotReadCorruptedTablePropertyError

public static Throwable cannotReadCorruptedTablePropertyError(String key,
                                                              String details)

invalidSchemaStringError

public static Throwable invalidSchemaStringError(org.apache.spark.sql.catalyst.expressions.Expression exp)

schemaNotFoldableError

public static Throwable schemaNotFoldableError(org.apache.spark.sql.catalyst.expressions.Expression exp)

schemaIsNotStructTypeError

public static Throwable schemaIsNotStructTypeError(DataType dataType)

keyValueInMapNotStringError

public static Throwable keyValueInMapNotStringError(org.apache.spark.sql.catalyst.expressions.CreateMap m)

nonMapFunctionNotAllowedError

public static Throwable nonMapFunctionNotAllowedError()

invalidFieldTypeForCorruptRecordError

public static Throwable invalidFieldTypeForCorruptRecordError()

dataTypeUnsupportedByClassError

public static Throwable dataTypeUnsupportedByClassError(DataType x,
                                                        String className)

parseModeUnsupportedError

public static Throwable parseModeUnsupportedError(String funcName,
                                                  org.apache.spark.sql.catalyst.util.ParseMode mode)

unfoldableFieldUnsupportedError

public static Throwable unfoldableFieldUnsupportedError()

literalTypeUnsupportedForSourceTypeError

public static Throwable literalTypeUnsupportedForSourceTypeError(String field,
                                                                 org.apache.spark.sql.catalyst.expressions.Expression source)

arrayComponentTypeUnsupportedError

public static Throwable arrayComponentTypeUnsupportedError(Class<?> clz)

secondArgumentNotDoubleLiteralError

public static Throwable secondArgumentNotDoubleLiteralError()

dataTypeUnsupportedByExtractValueError

public static Throwable dataTypeUnsupportedByExtractValueError(DataType dataType,
                                                               org.apache.spark.sql.catalyst.expressions.Expression extraction,
                                                               org.apache.spark.sql.catalyst.expressions.Expression child)

noHandlerForUDAFError

public static Throwable noHandlerForUDAFError(String name)

batchWriteCapabilityError

public static Throwable batchWriteCapabilityError(Table table,
                                                  String v2WriteClassName,
                                                  String v1WriteClassName)

unsupportedDeleteByConditionWithSubqueryError

public static Throwable unsupportedDeleteByConditionWithSubqueryError(scala.Option<org.apache.spark.sql.catalyst.expressions.Expression> condition)

cannotTranslateExpressionToSourceFilterError

public static Throwable cannotTranslateExpressionToSourceFilterError(org.apache.spark.sql.catalyst.expressions.Expression f)

cannotDeleteTableWhereFiltersError

public static Throwable cannotDeleteTableWhereFiltersError(Table table,
                                                           Filter[] filters)

deleteOnlySupportedWithV2TablesError

public static Throwable deleteOnlySupportedWithV2TablesError()

describeDoesNotSupportPartitionForV2TablesError

public static Throwable describeDoesNotSupportPartitionForV2TablesError()

cannotReplaceMissingTableError

public static Throwable cannotReplaceMissingTableError(Identifier tableIdentifier)

cannotReplaceMissingTableError

public static Throwable cannotReplaceMissingTableError(Identifier tableIdentifier,
                                                       scala.Option<Throwable> cause)

unsupportedTableOperationError

public static Throwable unsupportedTableOperationError(Table table,
                                                       String cmd)

unsupportedBatchReadError

public static Throwable unsupportedBatchReadError(Table table)

unsupportedMicroBatchOrContinuousScanError

public static Throwable unsupportedMicroBatchOrContinuousScanError(Table table)

unsupportedAppendInBatchModeError

public static Throwable unsupportedAppendInBatchModeError(Table table)

unsupportedDynamicOverwriteInBatchModeError

public static Throwable unsupportedDynamicOverwriteInBatchModeError(Table table)

unsupportedTruncateInBatchModeError

public static Throwable unsupportedTruncateInBatchModeError(Table table)

unsupportedOverwriteByFilterInBatchModeError

public static Throwable unsupportedOverwriteByFilterInBatchModeError(Table table)

streamingSourcesDoNotSupportCommonExecutionModeError

public static Throwable streamingSourcesDoNotSupportCommonExecutionModeError(scala.collection.Seq<String> microBatchSources,
                                                                             scala.collection.Seq<String> continuousSources)

noSuchTableError

public static Throwable noSuchTableError(Identifier ident)

noSuchNamespaceError

public static Throwable noSuchNamespaceError(String[] namespace)

tableAlreadyExistsError

public static Throwable tableAlreadyExistsError(Identifier ident)

requiresSinglePartNamespaceError

public static Throwable requiresSinglePartNamespaceError(scala.collection.Seq<String> ns)

namespaceAlreadyExistsError

public static Throwable namespaceAlreadyExistsError(String[] namespace)

cannotCreateJDBCTableUsingProviderError

public static Throwable cannotCreateJDBCTableUsingProviderError()

cannotCreateJDBCTableUsingLocationError

public static Throwable cannotCreateJDBCTableUsingLocationError()

cannotCreateJDBCNamespaceUsingProviderError

public static Throwable cannotCreateJDBCNamespaceUsingProviderError()

cannotCreateJDBCNamespaceWithPropertyError

public static Throwable cannotCreateJDBCNamespaceWithPropertyError(String k)

cannotSetJDBCNamespaceWithPropertyError

public static Throwable cannotSetJDBCNamespaceWithPropertyError(String k)

cannotUnsetJDBCNamespaceWithPropertyError

public static Throwable cannotUnsetJDBCNamespaceWithPropertyError(String k)

unsupportedJDBCNamespaceChangeInCatalogError

public static Throwable unsupportedJDBCNamespaceChangeInCatalogError(scala.collection.Seq<NamespaceChange> changes)

tableDoesNotSupportReadsError

public static Throwable tableDoesNotSupportReadsError(Table table)

tableDoesNotSupportWritesError

public static Throwable tableDoesNotSupportWritesError(Table table)

tableDoesNotSupportDeletesError

public static Throwable tableDoesNotSupportDeletesError(Table table)

tableDoesNotSupportTruncatesError

public static Throwable tableDoesNotSupportTruncatesError(Table table)

tableDoesNotSupportPartitionManagementError

public static Throwable tableDoesNotSupportPartitionManagementError(Table table)

tableDoesNotSupportAtomicPartitionManagementError

public static Throwable tableDoesNotSupportAtomicPartitionManagementError(Table table)

cannotRenameTableWithAlterViewError

public static Throwable cannotRenameTableWithAlterViewError()

analyzeTableNotSupportedForV2TablesError

public static Throwable analyzeTableNotSupportedForV2TablesError()

alterTableRecoverPartitionsNotSupportedForV2TablesError

public static Throwable alterTableRecoverPartitionsNotSupportedForV2TablesError()

alterTableSerDePropertiesNotSupportedForV2TablesError

public static Throwable alterTableSerDePropertiesNotSupportedForV2TablesError()

loadDataNotSupportedForV2TablesError

public static Throwable loadDataNotSupportedForV2TablesError()

showCreateTableAsSerdeNotSupportedForV2TablesError

public static Throwable showCreateTableAsSerdeNotSupportedForV2TablesError()

showColumnsNotSupportedForV2TablesError

public static Throwable showColumnsNotSupportedForV2TablesError()

repairTableNotSupportedForV2TablesError

public static Throwable repairTableNotSupportedForV2TablesError()

databaseFromV1SessionCatalogNotSpecifiedError

public static Throwable databaseFromV1SessionCatalogNotSpecifiedError()

nestedDatabaseUnsupportedByV1SessionCatalogError

public static Throwable nestedDatabaseUnsupportedByV1SessionCatalogError(String catalog)

invalidRepartitionExpressionsError

public static Throwable invalidRepartitionExpressionsError(scala.collection.Seq<Object> sortOrders)

partitionColumnNotSpecifiedError

public static Throwable partitionColumnNotSpecifiedError(String format,
                                                         String partitionColumn)

dataSchemaNotSpecifiedError

public static Throwable dataSchemaNotSpecifiedError(String format)

dataPathNotExistError

public static Throwable dataPathNotExistError(String path)

dataSourceOutputModeUnsupportedError

public static Throwable dataSourceOutputModeUnsupportedError(String className,
                                                             OutputMode outputMode)

schemaNotSpecifiedForSchemaRelationProviderError

public static Throwable schemaNotSpecifiedForSchemaRelationProviderError(String className)

userSpecifiedSchemaMismatchActualSchemaError

public static Throwable userSpecifiedSchemaMismatchActualSchemaError(StructType schema,
                                                                     StructType actualSchema)

dataSchemaNotSpecifiedError

public static Throwable dataSchemaNotSpecifiedError(String format,
                                                    String fileCatalog)

invalidDataSourceError

public static Throwable invalidDataSourceError(String className)

cannotSaveIntervalIntoExternalStorageError

public static Throwable cannotSaveIntervalIntoExternalStorageError()

cannotResolveAttributeError

public static Throwable cannotResolveAttributeError(String name,
                                                    String outputStr)

orcNotUsedWithHiveEnabledError

public static Throwable orcNotUsedWithHiveEnabledError()

failedToFindAvroDataSourceError

public static Throwable failedToFindAvroDataSourceError(String provider)

failedToFindKafkaDataSourceError

public static Throwable failedToFindKafkaDataSourceError(String provider)

findMultipleDataSourceError

public static Throwable findMultipleDataSourceError(String provider,
                                                    scala.collection.Seq<String> sourceNames)

writeEmptySchemasUnsupportedByDataSourceError

public static Throwable writeEmptySchemasUnsupportedByDataSourceError()

insertMismatchedColumnNumberError

public static Throwable insertMismatchedColumnNumberError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> targetAttributes,
                                                          scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> sourceAttributes,
                                                          int staticPartitionsSize)

insertMismatchedPartitionNumberError

public static Throwable insertMismatchedPartitionNumberError(StructType targetPartitionSchema,
                                                             int providedPartitionsSize)

invalidPartitionColumnError

public static Throwable invalidPartitionColumnError(String partKey,
                                                    StructType targetPartitionSchema)

multiplePartitionColumnValuesSpecifiedError

public static Throwable multiplePartitionColumnValuesSpecifiedError(StructField field,
                                                                    scala.collection.immutable.Map<String,String> potentialSpecs)

invalidOrderingForConstantValuePartitionColumnError

public static Throwable invalidOrderingForConstantValuePartitionColumnError(StructType targetPartitionSchema)

cannotWriteDataToRelationsWithMultiplePathsError

public static Throwable cannotWriteDataToRelationsWithMultiplePathsError()

failedToRebuildExpressionError

public static Throwable failedToRebuildExpressionError(Filter filter)

dataTypeUnsupportedByDataSourceError

public static Throwable dataTypeUnsupportedByDataSourceError(String format,
                                                             StructField field)

failToResolveDataSourceForTableError

public static Throwable failToResolveDataSourceForTableError(org.apache.spark.sql.catalyst.catalog.CatalogTable table,
                                                             String key)

outputPathAlreadyExistsError

public static Throwable outputPathAlreadyExistsError(org.apache.hadoop.fs.Path outputPath)

cannotUseDataTypeForPartitionColumnError

public static Throwable cannotUseDataTypeForPartitionColumnError(StructField field)

cannotUseAllColumnsForPartitionColumnsError

public static Throwable cannotUseAllColumnsForPartitionColumnsError()

partitionColumnNotFoundInSchemaError

public static Throwable partitionColumnNotFoundInSchemaError(String col,
                                                             String schemaCatalog)

columnNotFoundInSchemaError

public static Throwable columnNotFoundInSchemaError(StructField col,
                                                    scala.Option<StructType> tableSchema)

unsupportedDataSourceTypeForDirectQueryOnFilesError

public static Throwable unsupportedDataSourceTypeForDirectQueryOnFilesError(String className)

saveDataIntoViewNotAllowedError

public static Throwable saveDataIntoViewNotAllowedError()

mismatchedTableFormatError

public static Throwable mismatchedTableFormatError(String tableName,
                                                   Class<?> existingProvider,
                                                   Class<?> specifiedProvider)

mismatchedTableLocationError

public static Throwable mismatchedTableLocationError(org.apache.spark.sql.catalyst.TableIdentifier identifier,
                                                     org.apache.spark.sql.catalyst.catalog.CatalogTable existingTable,
                                                     org.apache.spark.sql.catalyst.catalog.CatalogTable tableDesc)

mismatchedTableColumnNumberError

public static Throwable mismatchedTableColumnNumberError(String tableName,
                                                         org.apache.spark.sql.catalyst.catalog.CatalogTable existingTable,
                                                         org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)

cannotResolveColumnGivenInputColumnsError

public static Throwable cannotResolveColumnGivenInputColumnsError(String col,
                                                                  String inputColumns)

mismatchedTablePartitionColumnError

public static Throwable mismatchedTablePartitionColumnError(String tableName,
                                                            scala.collection.Seq<String> specifiedPartCols,
                                                            String existingPartCols)

mismatchedTableBucketingError

public static Throwable mismatchedTableBucketingError(String tableName,
                                                      String specifiedBucketString,
                                                      String existingBucketString)

specifyPartitionNotAllowedWhenTableSchemaNotDefinedError

public static Throwable specifyPartitionNotAllowedWhenTableSchemaNotDefinedError()

bucketingColumnCannotBePartOfPartitionColumnsError

public static Throwable bucketingColumnCannotBePartOfPartitionColumnsError(String bucketCol,
                                                                           scala.collection.Seq<String> normalizedPartCols)

bucketSortingColumnCannotBePartOfPartitionColumnsError

public static Throwable bucketSortingColumnCannotBePartOfPartitionColumnsError(String sortCol,
                                                                               scala.collection.Seq<String> normalizedPartCols)

mismatchedInsertedDataColumnNumberError

public static Throwable mismatchedInsertedDataColumnNumberError(String tableName,
                                                                org.apache.spark.sql.catalyst.plans.logical.InsertIntoStatement insert,
                                                                scala.collection.immutable.Set<String> staticPartCols)

requestedPartitionsMismatchTablePartitionsError

public static Throwable requestedPartitionsMismatchTablePartitionsError(String tableName,
                                                                        scala.collection.immutable.Map<String,scala.Option<String>> normalizedPartSpec,
                                                                        StructType partColNames)

ddlWithoutHiveSupportEnabledError

public static Throwable ddlWithoutHiveSupportEnabledError(String detail)

createTableColumnTypesOptionColumnNotFoundInSchemaError

public static Throwable createTableColumnTypesOptionColumnNotFoundInSchemaError(String col,
                                                                                StructType schema)

parquetTypeUnsupportedYetError

public static Throwable parquetTypeUnsupportedYetError(String parquetType)

illegalParquetTypeError

public static Throwable illegalParquetTypeError(String parquetType)

unrecognizedParquetTypeError

public static Throwable unrecognizedParquetTypeError(String field)

cannotConvertDataTypeToParquetTypeError

public static Throwable cannotConvertDataTypeToParquetTypeError(StructField field)

incompatibleViewSchemaChange

public static Throwable incompatibleViewSchemaChange(String viewName,
                                                     String colName,
                                                     int expectedNum,
                                                     scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> actualCols,
                                                     scala.Option<String> viewDDL)

numberOfPartitionsNotAllowedWithUnspecifiedDistributionError

public static Throwable numberOfPartitionsNotAllowedWithUnspecifiedDistributionError()

cannotApplyTableValuedFunctionError

public static Throwable cannotApplyTableValuedFunctionError(String name,
                                                            String arguments,
                                                            String usage,
                                                            String details)

incompatibleRangeInputDataTypeError

public static Throwable incompatibleRangeInputDataTypeError(org.apache.spark.sql.catalyst.expressions.Expression expression,
                                                            DataType dataType)

groupAggPandasUDFUnsupportedByStreamingAggError

public static Throwable groupAggPandasUDFUnsupportedByStreamingAggError()

streamJoinStreamWithoutEqualityPredicateUnsupportedError

public static Throwable streamJoinStreamWithoutEqualityPredicateUnsupportedError(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan plan)

cannotUseMixtureOfAggFunctionAndGroupAggPandasUDFError

public static Throwable cannotUseMixtureOfAggFunctionAndGroupAggPandasUDFError()

ambiguousAttributesInSelfJoinError

public static Throwable ambiguousAttributesInSelfJoinError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.AttributeReference> ambiguousAttrs)

unexpectedEvalTypesForUDFsError

public static Throwable unexpectedEvalTypesForUDFsError(scala.collection.immutable.Set<Object> evalTypes)

ambiguousFieldNameError

public static Throwable ambiguousFieldNameError(scala.collection.Seq<String> fieldName,
                                                int numMatches,
                                                org.apache.spark.sql.catalyst.trees.Origin context)

cannotUseIntervalTypeInTableSchemaError

public static Throwable cannotUseIntervalTypeInTableSchemaError()

cannotConvertBucketWithSortColumnsToTransformError

public static Throwable cannotConvertBucketWithSortColumnsToTransformError(org.apache.spark.sql.catalyst.catalog.BucketSpec spec)

cannotConvertTransformsToPartitionColumnsError

public static Throwable cannotConvertTransformsToPartitionColumnsError(scala.collection.Seq<Transform> nonIdTransforms)

cannotPartitionByNestedColumnError

public static Throwable cannotPartitionByNestedColumnError(NamedReference reference)

cannotUseCatalogError

public static Throwable cannotUseCatalogError(CatalogPlugin plugin,
                                              String msg)

identifierHavingMoreThanTwoNamePartsError

public static Throwable identifierHavingMoreThanTwoNamePartsError(String quoted,
                                                                  String identifier)

emptyMultipartIdentifierError

public static Throwable emptyMultipartIdentifierError()

functionUnsupportedInV2CatalogError

public static Throwable functionUnsupportedInV2CatalogError()

cannotOperateOnHiveDataSourceFilesError

public static Throwable cannotOperateOnHiveDataSourceFilesError(String operation)

setPathOptionAndCallWithPathParameterError

public static Throwable setPathOptionAndCallWithPathParameterError(String method)

userSpecifiedSchemaUnsupportedError

public static Throwable userSpecifiedSchemaUnsupportedError(String operation)

tempViewNotSupportStreamingWriteError

public static Throwable tempViewNotSupportStreamingWriteError(String viewName)

streamingIntoViewNotSupportedError

public static Throwable streamingIntoViewNotSupportedError(String viewName)

inputSourceDiffersFromDataSourceProviderError

public static Throwable inputSourceDiffersFromDataSourceProviderError(String source,
                                                                      String tableName,
                                                                      org.apache.spark.sql.catalyst.catalog.CatalogTable table)

tableNotSupportStreamingWriteError

public static Throwable tableNotSupportStreamingWriteError(String tableName,
                                                           Table t)

queryNameNotSpecifiedForMemorySinkError

public static Throwable queryNameNotSpecifiedForMemorySinkError()

sourceNotSupportedWithContinuousTriggerError

public static Throwable sourceNotSupportedWithContinuousTriggerError(String source)

columnNotFoundInExistingColumnsError

public static Throwable columnNotFoundInExistingColumnsError(String columnType,
                                                             String columnName,
                                                             scala.collection.Seq<String> validColumnNames)

operationNotSupportPartitioningError

public static Throwable operationNotSupportPartitioningError(String operation)

mixedRefsInAggFunc

public static Throwable mixedRefsInAggFunc(String funcStr)

lookupFunctionInNonFunctionCatalogError

public static Throwable lookupFunctionInNonFunctionCatalogError(Identifier ident,
                                                                CatalogPlugin catalog)

functionCannotProcessInputError

public static Throwable functionCannotProcessInputError(UnboundFunction unbound,
                                                        scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> arguments,
                                                        UnsupportedOperationException unsupported)

v2FunctionInvalidInputTypeLengthError

public static Throwable v2FunctionInvalidInputTypeLengthError(BoundFunction bound,
                                                              scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> args)

ambiguousRelationAliasNameInNestedCTEError

public static Throwable ambiguousRelationAliasNameInNestedCTEError(String name)

commandUnsupportedInV2TableError

public static Throwable commandUnsupportedInV2TableError(String name)

cannotResolveColumnNameAmongAttributesError

public static Throwable cannotResolveColumnNameAmongAttributesError(String colName,
                                                                    String fieldNames)

cannotWriteTooManyColumnsToTableError

public static Throwable cannotWriteTooManyColumnsToTableError(String tableName,
                                                              scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> expected,
                                                              org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)

cannotWriteNotEnoughColumnsToTableError

public static Throwable cannotWriteNotEnoughColumnsToTableError(String tableName,
                                                                scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> expected,
                                                                org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)

cannotWriteIncompatibleDataToTableError

public static Throwable cannotWriteIncompatibleDataToTableError(String tableName,
                                                                scala.collection.Seq<String> errors)

secondArgumentOfFunctionIsNotIntegerError

public static Throwable secondArgumentOfFunctionIsNotIntegerError(String function,
                                                                  NumberFormatException e)

nonPartitionPruningPredicatesNotExpectedError

public static Throwable nonPartitionPruningPredicatesNotExpectedError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> nonPartitionPruningPredicates)

columnNotDefinedInTableError

public static Throwable columnNotDefinedInTableError(String colType,
                                                     String colName,
                                                     String tableName,
                                                     scala.collection.Seq<String> tableCols)

invalidLiteralForWindowDurationError

public static Throwable invalidLiteralForWindowDurationError()

noSuchStructFieldInGivenFieldsError

public static Throwable noSuchStructFieldInGivenFieldsError(String fieldName,
                                                            StructField[] fields)

ambiguousReferenceToFieldsError

public static Throwable ambiguousReferenceToFieldsError(String fields)

secondArgumentInFunctionIsNotBooleanLiteralError

public static Throwable secondArgumentInFunctionIsNotBooleanLiteralError(String funcName)

joinConditionMissingOrTrivialError

public static Throwable joinConditionMissingOrTrivialError(org.apache.spark.sql.catalyst.plans.logical.Join join,
                                                           org.apache.spark.sql.catalyst.plans.logical.LogicalPlan left,
                                                           org.apache.spark.sql.catalyst.plans.logical.LogicalPlan right)

usePythonUDFInJoinConditionUnsupportedError

public static Throwable usePythonUDFInJoinConditionUnsupportedError(org.apache.spark.sql.catalyst.plans.JoinType joinType)

conflictingAttributesInJoinConditionError

public static Throwable conflictingAttributesInJoinConditionError(org.apache.spark.sql.catalyst.expressions.AttributeSet conflictingAttrs,
                                                                  org.apache.spark.sql.catalyst.plans.logical.LogicalPlan outerPlan,
                                                                  org.apache.spark.sql.catalyst.plans.logical.LogicalPlan subplan)

emptyWindowExpressionError

public static Throwable emptyWindowExpressionError(org.apache.spark.sql.catalyst.plans.logical.Window expr)

foundDifferentWindowFunctionTypeError

public static Throwable foundDifferentWindowFunctionTypeError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.NamedExpression> windowExpressions)

charOrVarcharTypeAsStringUnsupportedError

public static Throwable charOrVarcharTypeAsStringUnsupportedError()

invalidPatternError

public static Throwable invalidPatternError(String pattern,
                                            String message)

tableIdentifierExistsError

public static Throwable tableIdentifierExistsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdentifier)

tableIdentifierNotConvertedToHadoopFsRelationError

public static Throwable tableIdentifierNotConvertedToHadoopFsRelationError(org.apache.spark.sql.catalyst.TableIdentifier tableIdentifier)

alterDatabaseLocationUnsupportedError

public static Throwable alterDatabaseLocationUnsupportedError(String version)

hiveTableTypeUnsupportedError

public static Throwable hiveTableTypeUnsupportedError(String tableType)

hiveCreatePermanentFunctionsUnsupportedError

public static Throwable hiveCreatePermanentFunctionsUnsupportedError()

unknownHiveResourceTypeError

public static Throwable unknownHiveResourceTypeError(String resourceType)

invalidDayTimeField

public static Throwable invalidDayTimeField(byte field)

invalidDayTimeIntervalType

public static Throwable invalidDayTimeIntervalType(String startFieldName,
                                                   String endFieldName)

invalidYearMonthField

public static Throwable invalidYearMonthField(byte field)

invalidYearMonthIntervalType

public static Throwable invalidYearMonthIntervalType(String startFieldName,
                                                     String endFieldName)

configRemovedInVersionError

public static Throwable configRemovedInVersionError(String configName,
                                                    String version,
                                                    String comment)

failedFallbackParsingError

public static Throwable failedFallbackParsingError(String msg,
                                                   Throwable e1,
                                                   Throwable e2)

decimalCannotGreaterThanPrecisionError

public static Throwable decimalCannotGreaterThanPrecisionError(int scale,
                                                               int precision)

decimalOnlySupportPrecisionUptoError

public static Throwable decimalOnlySupportPrecisionUptoError(String decimalType,
                                                             int precision)

negativeScaleNotAllowedError

public static Throwable negativeScaleNotAllowedError(int scale)

invalidPartitionColumnKeyInTableError

public static Throwable invalidPartitionColumnKeyInTableError(String key,
                                                              String tblName)

invalidPartitionSpecError

public static Throwable invalidPartitionSpecError(String specKeys,
                                                  scala.collection.Seq<String> partitionColumnNames,
                                                  String tableName)

foundDuplicateColumnError

public static Throwable foundDuplicateColumnError(String colType,
                                                  scala.collection.Seq<String> duplicateCol)

noSuchTableError

public static Throwable noSuchTableError(String db,
                                         String table)

tempViewNotCachedForAnalyzingColumnsError

public static Throwable tempViewNotCachedForAnalyzingColumnsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)

columnTypeNotSupportStatisticsCollectionError

public static Throwable columnTypeNotSupportStatisticsCollectionError(String name,
                                                                      org.apache.spark.sql.catalyst.TableIdentifier tableIdent,
                                                                      DataType dataType)

analyzeTableNotSupportedOnViewsError

public static Throwable analyzeTableNotSupportedOnViewsError()

unexpectedPartitionColumnPrefixError

public static Throwable unexpectedPartitionColumnPrefixError(String table,
                                                             String database,
                                                             String schemaColumns,
                                                             String specColumns)

noSuchPartitionError

public static Throwable noSuchPartitionError(String db,
                                             String table,
                                             scala.collection.immutable.Map<String,String> partition)

analyzingColumnStatisticsNotSupportedForColumnTypeError

public static Throwable analyzingColumnStatisticsNotSupportedForColumnTypeError(String name,
                                                                                DataType dataType)

tableAlreadyExistsError

public static Throwable tableAlreadyExistsError(String table,
                                                String guide)

createTableAsSelectWithNonEmptyDirectoryError

public static Throwable createTableAsSelectWithNonEmptyDirectoryError(String tablePath)

tableOrViewNotFoundError

public static Throwable tableOrViewNotFoundError(String table)

unsetNonExistentPropertyError

public static Throwable unsetNonExistentPropertyError(String property,
                                                      org.apache.spark.sql.catalyst.TableIdentifier table)

alterTableChangeColumnNotSupportedForColumnTypeError

public static Throwable alterTableChangeColumnNotSupportedForColumnTypeError(StructField originColumn,
                                                                             StructField newColumn)

cannotFindColumnError

public static Throwable cannotFindColumnError(String name,
                                              String[] fieldNames)

alterTableSetSerdeForSpecificPartitionNotSupportedError

public static Throwable alterTableSetSerdeForSpecificPartitionNotSupportedError()

alterTableSetSerdeNotSupportedError

public static Throwable alterTableSetSerdeNotSupportedError()

cmdOnlyWorksOnPartitionedTablesError

public static Throwable cmdOnlyWorksOnPartitionedTablesError(String cmd,
                                                             String tableIdentWithDB)

cmdOnlyWorksOnTableWithLocationError

public static Throwable cmdOnlyWorksOnTableWithLocationError(String cmd,
                                                             String tableIdentWithDB)

actionNotAllowedOnTableWithFilesourcePartitionManagementDisabledError

public static Throwable actionNotAllowedOnTableWithFilesourcePartitionManagementDisabledError(String action,
                                                                                              String tableName)

actionNotAllowedOnTableSincePartitionMetadataNotStoredError

public static Throwable actionNotAllowedOnTableSincePartitionMetadataNotStoredError(String action,
                                                                                    String tableName)

cannotAlterViewWithAlterTableError

public static Throwable cannotAlterViewWithAlterTableError()

cannotAlterTableWithAlterViewError

public static Throwable cannotAlterTableWithAlterViewError()

cannotOverwritePathBeingReadFromError

public static Throwable cannotOverwritePathBeingReadFromError()

createFuncWithBothIfNotExistsAndReplaceError

public static Throwable createFuncWithBothIfNotExistsAndReplaceError()

defineTempFuncWithIfNotExistsError

public static Throwable defineTempFuncWithIfNotExistsError()

specifyingDBInCreateTempFuncError

public static Throwable specifyingDBInCreateTempFuncError(String databaseName)

specifyingDBInDropTempFuncError

public static Throwable specifyingDBInDropTempFuncError(String databaseName)

cannotDropNativeFuncError

public static Throwable cannotDropNativeFuncError(String functionName)

cannotRefreshBuiltInFuncError

public static Throwable cannotRefreshBuiltInFuncError(String functionName)

cannotRefreshTempFuncError

public static Throwable cannotRefreshTempFuncError(String functionName)

noSuchFunctionError

public static Throwable noSuchFunctionError(org.apache.spark.sql.catalyst.FunctionIdentifier identifier)

alterAddColNotSupportViewError

public static Throwable alterAddColNotSupportViewError(org.apache.spark.sql.catalyst.TableIdentifier table)

alterAddColNotSupportDatasourceTableError

public static Throwable alterAddColNotSupportDatasourceTableError(Object tableType,
                                                                  org.apache.spark.sql.catalyst.TableIdentifier table)

loadDataNotSupportedForDatasourceTablesError

public static Throwable loadDataNotSupportedForDatasourceTablesError(String tableIdentWithDB)

loadDataWithoutPartitionSpecProvidedError

public static Throwable loadDataWithoutPartitionSpecProvidedError(String tableIdentWithDB)

loadDataPartitionSizeNotMatchNumPartitionColumnsError

public static Throwable loadDataPartitionSizeNotMatchNumPartitionColumnsError(String tableIdentWithDB,
                                                                              int partitionSize,
                                                                              int targetTableSize)

loadDataTargetTableNotPartitionedButPartitionSpecWasProvidedError

public static Throwable loadDataTargetTableNotPartitionedButPartitionSpecWasProvidedError(String tableIdentWithDB)

loadDataInputPathNotExistError

public static Throwable loadDataInputPathNotExistError(String path)

truncateTableOnExternalTablesError

public static Throwable truncateTableOnExternalTablesError(String tableIdentWithDB)

truncateTablePartitionNotSupportedForNotPartitionedTablesError

public static Throwable truncateTablePartitionNotSupportedForNotPartitionedTablesError(String tableIdentWithDB)

failToTruncateTableWhenRemovingDataError

public static Throwable failToTruncateTableWhenRemovingDataError(String tableIdentWithDB,
                                                                 org.apache.hadoop.fs.Path path,
                                                                 Throwable e)

descPartitionNotAllowedOnTempView

public static Throwable descPartitionNotAllowedOnTempView(String table)

descPartitionNotAllowedOnView

public static Throwable descPartitionNotAllowedOnView(String table)

showPartitionNotAllowedOnTableNotPartitionedError

public static Throwable showPartitionNotAllowedOnTableNotPartitionedError(String tableIdentWithDB)

showCreateTableNotSupportedOnTempView

public static Throwable showCreateTableNotSupportedOnTempView(String table)

showCreateTableFailToExecuteUnsupportedFeatureError

public static Throwable showCreateTableFailToExecuteUnsupportedFeatureError(org.apache.spark.sql.catalyst.catalog.CatalogTable table)

showCreateTableNotSupportTransactionalHiveTableError

public static Throwable showCreateTableNotSupportTransactionalHiveTableError(org.apache.spark.sql.catalyst.catalog.CatalogTable table)

showCreateTableFailToExecuteUnsupportedConfError

public static Throwable showCreateTableFailToExecuteUnsupportedConfError(org.apache.spark.sql.catalyst.TableIdentifier table,
                                                                         scala.collection.mutable.StringBuilder builder)

descPartitionNotAllowedOnViewError

public static Throwable descPartitionNotAllowedOnViewError(String table)

showCreateTableAsSerdeNotAllowedOnSparkDataSourceTableError

public static Throwable showCreateTableAsSerdeNotAllowedOnSparkDataSourceTableError(org.apache.spark.sql.catalyst.TableIdentifier table)

showCreateTableOrViewFailToExecuteUnsupportedFeatureError

public static Throwable showCreateTableOrViewFailToExecuteUnsupportedFeatureError(org.apache.spark.sql.catalyst.catalog.CatalogTable table,
                                                                                  scala.collection.Seq<String> features)

createViewWithBothIfNotExistsAndReplaceError

public static Throwable createViewWithBothIfNotExistsAndReplaceError()

defineTempViewWithIfNotExistsError

public static Throwable defineTempViewWithIfNotExistsError()

notAllowedToAddDBPrefixForTempViewError

public static Throwable notAllowedToAddDBPrefixForTempViewError(String database)

logicalPlanForViewNotAnalyzedError

public static Throwable logicalPlanForViewNotAnalyzedError()

createViewNumColumnsMismatchUserSpecifiedColumnLengthError

public static Throwable createViewNumColumnsMismatchUserSpecifiedColumnLengthError(int analyzedPlanLength,
                                                                                   int userSpecifiedColumnsLength)

tableIsNotViewError

public static Throwable tableIsNotViewError(org.apache.spark.sql.catalyst.TableIdentifier name)

viewAlreadyExistsError

public static Throwable viewAlreadyExistsError(org.apache.spark.sql.catalyst.TableIdentifier name)

createPersistedViewFromDatasetAPINotAllowedError

public static Throwable createPersistedViewFromDatasetAPINotAllowedError()

recursiveViewDetectedError

public static Throwable recursiveViewDetectedError(org.apache.spark.sql.catalyst.TableIdentifier viewIdent,
                                                   scala.collection.Seq<org.apache.spark.sql.catalyst.TableIdentifier> newPath)

notAllowedToCreatePermanentViewWithoutAssigningAliasForExpressionError

public static Throwable notAllowedToCreatePermanentViewWithoutAssigningAliasForExpressionError(org.apache.spark.sql.catalyst.TableIdentifier name,
                                                                                               String attrName)

notAllowedToCreatePermanentViewByReferencingTempViewError

public static Throwable notAllowedToCreatePermanentViewByReferencingTempViewError(org.apache.spark.sql.catalyst.TableIdentifier name,
                                                                                  String nameParts)

notAllowedToCreatePermanentViewByReferencingTempFuncError

public static Throwable notAllowedToCreatePermanentViewByReferencingTempFuncError(org.apache.spark.sql.catalyst.TableIdentifier name,
                                                                                  String funcName)

queryFromRawFilesIncludeCorruptRecordColumnError

public static Throwable queryFromRawFilesIncludeCorruptRecordColumnError()

userDefinedPartitionNotFoundInJDBCRelationError

public static Throwable userDefinedPartitionNotFoundInJDBCRelationError(String columnName,
                                                                        String schema)

invalidPartitionColumnTypeError

public static Throwable invalidPartitionColumnTypeError(StructField column)

tableOrViewAlreadyExistsError

public static Throwable tableOrViewAlreadyExistsError(String name)

columnNameContainsInvalidCharactersError

public static Throwable columnNameContainsInvalidCharactersError(String name)

textDataSourceWithMultiColumnsError

public static Throwable textDataSourceWithMultiColumnsError(StructType schema)

cannotFindPartitionColumnInPartitionSchemaError

public static Throwable cannotFindPartitionColumnInPartitionSchemaError(StructField readField,
                                                                        StructType partitionSchema)

cannotSpecifyDatabaseForTempViewError

public static Throwable cannotSpecifyDatabaseForTempViewError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)

cannotCreateTempViewUsingHiveDataSourceError

public static Throwable cannotCreateTempViewUsingHiveDataSourceError()

invalidTimestampProvidedForStrategyError

public static Throwable invalidTimestampProvidedForStrategyError(String strategy,
                                                                 String timeString)

hostOptionNotSetError

public static Throwable hostOptionNotSetError()

portOptionNotSetError

public static Throwable portOptionNotSetError()

invalidIncludeTimestampValueError

public static Throwable invalidIncludeTimestampValueError()

checkpointLocationNotSpecifiedError

public static Throwable checkpointLocationNotSpecifiedError()

recoverQueryFromCheckpointUnsupportedError

public static Throwable recoverQueryFromCheckpointUnsupportedError(org.apache.hadoop.fs.Path checkpointPath)

cannotFindColumnInRelationOutputError

public static Throwable cannotFindColumnInRelationOutputError(String colName,
                                                              org.apache.spark.sql.catalyst.plans.logical.LogicalPlan relation)

invalidBoundaryStartError

public static Throwable invalidBoundaryStartError(long start)

invalidBoundaryEndError

public static Throwable invalidBoundaryEndError(long end)

databaseDoesNotExistError

public static Throwable databaseDoesNotExistError(String dbName)

tableDoesNotExistInDatabaseError

public static Throwable tableDoesNotExistInDatabaseError(String tableName,
                                                         String dbName)

tableOrViewNotFoundInDatabaseError

public static Throwable tableOrViewNotFoundInDatabaseError(String tableName,
                                                           String dbName)

unexpectedTypeOfRelationError

public static Throwable unexpectedTypeOfRelationError(org.apache.spark.sql.catalyst.plans.logical.LogicalPlan relation,
                                                      String tableName)

unsupportedTableChangeInJDBCCatalogError

public static Throwable unsupportedTableChangeInJDBCCatalogError(TableChange change)

pathOptionNotSetCorrectlyWhenReadingError

public static Throwable pathOptionNotSetCorrectlyWhenReadingError()

pathOptionNotSetCorrectlyWhenWritingError

public static Throwable pathOptionNotSetCorrectlyWhenWritingError()

writeWithSaveModeUnsupportedBySourceError

public static Throwable writeWithSaveModeUnsupportedBySourceError(String source,
                                                                  String createMode)

partitionByDoesNotAllowedWhenUsingInsertIntoError

public static Throwable partitionByDoesNotAllowedWhenUsingInsertIntoError()

cannotFindCatalogToHandleIdentifierError

public static Throwable cannotFindCatalogToHandleIdentifierError(String quote)

sortByNotUsedWithBucketByError

public static Throwable sortByNotUsedWithBucketByError()

bucketByUnsupportedByOperationError

public static Throwable bucketByUnsupportedByOperationError(String operation)

bucketByAndSortByUnsupportedByOperationError

public static Throwable bucketByAndSortByUnsupportedByOperationError(String operation)

tableAlreadyExistsError

public static Throwable tableAlreadyExistsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)

cannotOverwriteTableThatIsBeingReadFromError

public static Throwable cannotOverwriteTableThatIsBeingReadFromError(String tableName)

invalidPartitionTransformationError

public static Throwable invalidPartitionTransformationError(org.apache.spark.sql.catalyst.expressions.Expression expr)

cannotResolveColumnNameAmongFieldsError

public static AnalysisException cannotResolveColumnNameAmongFieldsError(String colName,
                                                                        String fieldsStr,
                                                                        String extraMsg)

cannotParseIntervalError

public static Throwable cannotParseIntervalError(String delayThreshold,
                                                 Throwable e)

invalidJoinTypeInJoinWithError

public static Throwable invalidJoinTypeInJoinWithError(org.apache.spark.sql.catalyst.plans.JoinType joinType)

cannotPassTypedColumnInUntypedSelectError

public static Throwable cannotPassTypedColumnInUntypedSelectError(String typedCol)

invalidViewNameError

public static Throwable invalidViewNameError(String viewName)

invalidBucketsNumberError

public static Throwable invalidBucketsNumberError(String numBuckets,
                                                  String e)

usingUntypedScalaUDFError

public static Throwable usingUntypedScalaUDFError()

aggregationFunctionAppliedOnNonNumericColumnError

public static Throwable aggregationFunctionAppliedOnNonNumericColumnError(String colName)

aggregationFunctionAppliedOnNonNumericColumnError

public static Throwable aggregationFunctionAppliedOnNonNumericColumnError(String pivotColumn,
                                                                          int maxValues)

cannotModifyValueOfStaticConfigError

public static Throwable cannotModifyValueOfStaticConfigError(String key)

cannotModifyValueOfSparkConfigError

public static Throwable cannotModifyValueOfSparkConfigError(String key)

commandExecutionInRunnerUnsupportedError

public static Throwable commandExecutionInRunnerUnsupportedError(String runner)

udfClassDoesNotImplementAnyUDFInterfaceError

public static Throwable udfClassDoesNotImplementAnyUDFInterfaceError(String className)

udfClassNotAllowedToImplementMultiUDFInterfacesError

public static Throwable udfClassNotAllowedToImplementMultiUDFInterfacesError(String className)

udfClassWithTooManyTypeArgumentsError

public static Throwable udfClassWithTooManyTypeArgumentsError(int n)

classWithoutPublicNonArgumentConstructorError

public static Throwable classWithoutPublicNonArgumentConstructorError(String className)

cannotLoadClassNotOnClassPathError

public static Throwable cannotLoadClassNotOnClassPathError(String className)

classDoesNotImplementUserDefinedAggregateFunctionError

public static Throwable classDoesNotImplementUserDefinedAggregateFunctionError(String className)

missingFieldError

public static Throwable missingFieldError(scala.collection.Seq<String> fieldName,
                                          org.apache.spark.sql.catalyst.analysis.ResolvedTable table,
                                          org.apache.spark.sql.catalyst.trees.Origin context)

invalidFieldName

public static Throwable invalidFieldName(scala.collection.Seq<String> fieldName,
                                         scala.collection.Seq<String> path,
                                         org.apache.spark.sql.catalyst.trees.Origin context)

Class QueryCompilationErrors

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

QueryCompilationErrors

Method Detail

groupingIDMismatchError

groupingColInvalidError

groupingSizeTooLargeError

unorderablePivotColError

nonLiteralPivotValError

pivotValDataTypeMismatchError

unsupportedIfNotExistsError

nonPartitionColError

missingStaticPartitionColumn

nestedGeneratorError

moreThanOneGeneratorError

generatorOutsideSelectError

legacyStoreAssignmentPolicyError

unresolvedUsingColForJoinError

dataTypeMismatchForDeserializerError

fieldNumberMismatchForDeserializerError

upCastFailureError

unsupportedAbstractDataTypeForUpCastError

outerScopeFailureForNewInstanceError

referenceColNotFoundForAlterTableChangesError

windowSpecificationNotDefinedError

selectExprNotInGroupByError

groupingMustWithGroupingSetsOrCubeOrRollupError

pandasUDFAggregateNotSupportedInPivotError

aggregateExpressionRequiredForPivotError

writeIntoTempViewNotAllowedError

expectTableOrPermanentViewNotTempViewError

readNonStreamingTempViewError

viewDepthExceedsMaxResolutionDepthError

insertIntoViewNotAllowedError

writeIntoViewNotAllowedError

writeIntoV1TableNotAllowedError

expectTableNotViewError

expectViewNotTableError

permanentViewNotSupportedByStreamingReadingAPIError

starNotAllowedWhenGroupByOrdinalPositionUsedError

invalidStarUsageError

singleTableStarInCountNotAllowedError

orderByPositionRangeError

groupByPositionRefersToAggregateFunctionError

groupByPositionRangeError

generatorNotExpectedError

functionWithUnsupportedSyntaxError

nonDeterministicFilterInAggregateError

aliasNumberNotMatchColumnNumberError

aliasesNumberNotMatchUDTFOutputError

windowAggregateFunctionWithFilterNotSupportedError

windowFunctionInsideAggregateFunctionNotAllowedError

expressionWithoutWindowExpressionError

expressionWithMultiWindowExpressionsError

windowFunctionNotAllowedError

cannotSpecifyWindowFrameError

windowFrameNotMatchRequiredFrameError

windowFunctionWithWindowFrameNotOrderedError

cannotResolveUserSpecifiedColumnsError

writeTableWithMismatchedColumnsError

multiTimeWindowExpressionsNotSupportedError

sessionWindowGapDurationDataTypeError

viewOutputNumberMismatchQueryColumnNamesError

attributeNotFoundError

cannotUpCastAsAttributeError

functionUndefinedError

invalidFunctionArgumentsError

invalidFunctionArgumentNumberError

functionAcceptsOnlyOneArgumentError

alterV2TableSetLocationWithPartitionNotSupportedError

joinStrategyHintParameterNotSupportedError

invalidHintParameterError

invalidCoalesceHintParameterError

attributeNameSyntaxError

starExpandDataTypeNotSupportedError

cannotResolveStarExpandGivenInputColumnsError

addColumnWithV1TableCannotSpecifyNotNullError