QueryCompilationErrors (Spark 3.5.0 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`	`addNewDefaultColumnToExistingTableNotAllowed(String statementType, String dataSource)`
`static Throwable`	`aggregateExpressionRequiredForPivotError(String sql)`
`static Throwable`	`aggregateInAggregateFilterError()`
`static Throwable`	`aggregationFunctionAppliedOnNonNumericColumnError(String colName)`
`static Throwable`	`aggregationFunctionAppliedOnNonNumericColumnError(String pivotColumn, int maxValues)`
`static Throwable`	`aggregationNotAllowedInMergeCondition(String condName, org.apache.spark.sql.catalyst.expressions.Expression cond)`
`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()`
`static Throwable`	`alterTableChangeColumnNotSupportedForColumnTypeError(String tableName, 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`	`ambiguousColumnOrFieldError(scala.collection.Seq<String> name, int numMatches, org.apache.spark.sql.catalyst.trees.Origin context)`
`static Throwable`	`ambiguousLateralColumnAliasError(scala.collection.Seq<String> nameParts, int numOfMatches)`
`static Throwable`	`ambiguousLateralColumnAliasError(String name, int numOfMatches)`
`static Throwable`	`ambiguousReferenceError(String name, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> ambiguousReferences)`
`static Throwable`	`ambiguousReferenceToFieldsError(String field, int numberOfAppearance)`
`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`	`batchWriteCapabilityError(org.apache.spark.sql.connector.catalog.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`	`cannotConvertCatalystTypeToProtobufTypeError(scala.collection.Seq<String> sqlColumn, String protobufColumn, DataType sqlType, String protobufType)`
`static Throwable`	`cannotConvertDataTypeToParquetTypeError(StructField field)`
`static Throwable`	`cannotConvertProtobufTypeToCatalystTypeError(String protobufType, DataType sqlType, Throwable cause)`
`static Throwable`	`cannotConvertProtobufTypeToSqlTypeError(String protobufColumn, scala.collection.Seq<String> sqlColumn, String protobufType, DataType sqlType)`
`static Throwable`	`cannotConvertSqlTypeToProtobufError(String protobufType, DataType sqlType, Throwable cause)`
`static Throwable`	`cannotCreateDatabaseWithSameNameAsPreservedDatabaseError(String database)`
`static Throwable`	`cannotCreateJDBCNamespaceUsingProviderError()`
`static Throwable`	`cannotCreateJDBCNamespaceWithPropertyError(String property)`
`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`	`cannotCreateViewNotEnoughColumnsError(org.apache.spark.sql.catalyst.TableIdentifier viewIdent, scala.collection.Seq<String> expected, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)`
`static Throwable`	`cannotCreateViewTooManyColumnsError(org.apache.spark.sql.catalyst.TableIdentifier viewIdent, scala.collection.Seq<String> expected, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)`
`static Throwable`	`cannotDeleteTableWhereFiltersError(org.apache.spark.sql.connector.catalog.Table table, org.apache.spark.sql.connector.expressions.filter.Predicate[] filters)`
`static Throwable`	`cannotDropBuiltinFuncError(String functionName)`
`static Throwable`	`cannotDropDefaultDatabaseError(String database)`
`static Throwable`	`cannotDropNonemptyDatabaseError(String db)`
`static Throwable`	`cannotDropNonemptyNamespaceError(scala.collection.Seq<String> namespace)`
`static Throwable`	`cannotFindCatalogToHandleIdentifierError(String quote)`
`static Throwable`	`cannotFindCatalystTypeInProtobufSchemaError(String catalystFieldPath)`
`static Throwable`	`cannotFindColumnError(String name, String[] fieldNames)`
`static Throwable`	`cannotFindColumnInRelationOutputError(String colName, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan relation)`
`static AnalysisException`	`cannotFindDescriptorFileError(String filePath, Throwable cause)`
`static Throwable`	`cannotFindPartitionColumnInPartitionSchemaError(StructField readField, StructType partitionSchema)`
`static Throwable`	`cannotFindProtobufFieldInCatalystError(String field)`
`static Throwable`	`cannotLoadClassNotOnClassPathError(String className)`
`static Throwable`	`cannotLoadClassWhenRegisteringFunctionError(String className, org.apache.spark.sql.catalyst.FunctionIdentifier func)`
`static Throwable`	`cannotModifyValueOfSparkConfigError(String key, String docroot)`
`static Throwable`	`cannotModifyValueOfStaticConfigError(String key)`
`static Throwable`	`cannotOperateOnHiveDataSourceFilesError(String operation)`
`static Throwable`	`cannotOverwritePathBeingReadFromError(String path)`
`static Throwable`	`cannotOverwriteTableThatIsBeingReadFromError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)`
`static Throwable`	`cannotParseIntervalError(String delayThreshold, Throwable e)`
`static Throwable`	`cannotPassTypedColumnInUntypedSelectError(String typedCol)`
`static Throwable`	`cannotRefreshBuiltInFuncError(String functionName)`
`static Throwable`	`cannotRefreshTempFuncError(String functionName)`
`static Throwable`	`cannotRenameTableAcrossSchemaError()`
`static Throwable`	`cannotRenameTableWithAlterViewError()`
`static Throwable`	`cannotRenameTempViewToExistingTableError(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(org.apache.spark.sql.connector.catalog.Identifier tableIdentifier)`
`static Throwable`	`cannotReplaceMissingTableError(org.apache.spark.sql.connector.catalog.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 Throwable`	`cannotResolveStarExpandGivenInputColumnsError(String targetString, String columns)`
`static Throwable`	`cannotRetrieveTableOrViewNotInSameDatabaseError(scala.collection.Seq<org.apache.spark.sql.catalyst.QualifiedTableName> qualifiedTableNames)`
`static Throwable`	`cannotSaveIntervalIntoExternalStorageError()`
`static Throwable`	`cannotSetJDBCNamespaceWithPropertyError(String property)`
`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 property)`
`static Throwable`	`cannotUseAllColumnsForPartitionColumnsError()`
`static Throwable`	`cannotUseDataTypeForPartitionColumnError(StructField field)`
`static Throwable`	`cannotUseIntervalTypeInTableSchemaError()`
`static Throwable`	`cannotUsePreservedDatabaseAsCurrentDatabaseError(String database)`
`static Throwable`	`cannotWriteDataToRelationsWithMultiplePathsError()`
`static Throwable`	`cannotWriteNotEnoughColumnsToTableError(String tableName, scala.collection.Seq<String> expected, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> queryOutput)`
`static Throwable`	`cannotWriteTooManyColumnsToTableError(String tableName, scala.collection.Seq<String> expected, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> queryOutput)`
`static Throwable`	`catalogOperationNotSupported(org.apache.spark.sql.connector.catalog.CatalogPlugin catalog, String operation)`
`static Throwable`	`charOrVarcharTypeAsStringUnsupportedError()`
`static Throwable`	`checkpointLocationNotSpecifiedError()`
`static Throwable`	`classDoesNotImplementUserDefinedAggregateFunctionError(String className)`
`static Throwable`	`classWithoutPublicNonArgumentConstructorError(String className)`
`static Throwable`	`cmdOnlyWorksOnPartitionedTablesError(String operation, String tableIdentWithDB)`
`static Throwable`	`cmdOnlyWorksOnTableWithLocationError(String cmd, String tableIdentWithDB)`
`static Throwable`	`columnAlreadyExistsError(String columnName)`
`static Throwable`	`columnNotDefinedInTableError(String colType, String colName, String tableName, scala.collection.Seq<String> tableCols)`
`static AnalysisException`	`columnNotFoundError(String colName)`
`static Throwable`	`columnNotFoundInExistingColumnsError(String columnType, String columnName, scala.collection.Seq<String> validColumnNames)`
`static Throwable`	`columnNotFoundInSchemaError(StructField col, scala.Option<StructType> tableSchema)`
`static Throwable`	`columnNotInGroupByClauseError(org.apache.spark.sql.catalyst.expressions.Expression expression)`
`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`	`createPersistedViewFromDatasetAPINotAllowedError()`
`static Throwable`	`createTableAsSelectWithNonEmptyDirectoryError(String tablePath)`
`static Throwable`	`createTableColumnTypesOptionColumnNotFoundInSchemaError(String col, StructType schema)`
`static Throwable`	`databaseFromV1SessionCatalogNotSpecifiedError()`
`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`	`dataTypeOperationUnsupportedError()`
`static Throwable`	`dataTypeUnsupportedByClassError(DataType x, String className)`
`static Throwable`	`dataTypeUnsupportedByDataSourceError(String format, StructField column)`
`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 cmd)`
`static Throwable`	`defaultReferencesNotAllowedInComplexExpressionsInInsertValuesList()`
`static Throwable`	`defaultReferencesNotAllowedInComplexExpressionsInMergeInsertsOrUpdates()`
`static Throwable`	`defaultReferencesNotAllowedInComplexExpressionsInUpdateSetClause()`
`static Throwable`	`defaultReferencesNotAllowedInDataSource(String statementType, String dataSource)`
`static Throwable`	`defaultValuesDataTypeError(String statement, String colName, String defaultValue, DataType expectedType, DataType actualType)`
`static Throwable`	`defaultValuesMayNotContainSubQueryExpressions(String statement, String colName, String defaultValue)`
`static Throwable`	`defaultValuesUnresolvedExprError(String statement, String colName, String defaultValue, Throwable cause)`
`static Throwable`	`descPartitionNotAllowedOnTempView(String table)`
`static Throwable`	`descPartitionNotAllowedOnView(String table)`
`static Throwable`	`describeDoesNotSupportPartitionForV2TablesError()`
`static AnalysisException`	`descriptorParseError(Throwable cause)`
`static Throwable`	`doubleNamedArgumentReference(String functionName, String parameterName)`
`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`	`escapeCharacterAtTheEndError(String pattern)`
`static Throwable`	`escapeCharacterInTheMiddleError(String pattern, String char_)`
`static Throwable`	`expectPersistentFuncError(String name, String cmd, scala.Option<String> mismatchHint, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`expectTableNotViewError(scala.collection.Seq<String> nameParts, boolean isTemp, String cmd, scala.Option<String> mismatchHint, org.apache.spark.sql.catalyst.trees.TreeNode<?> t)`
`static Throwable`	`expectTableOrPermanentViewNotTempViewError(scala.collection.Seq<String> nameParts, 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`	`expectViewNotTempViewError(scala.collection.Seq<String> nameParts, String cmd, 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`	`failedToFindAvroDataSourceError(String provider)`
`static Throwable`	`failedToFindKafkaDataSourceError(String provider)`
`static Throwable`	`failedToParseExistenceDefaultAsLiteral(String fieldName, String defaultValue)`
`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`	`foundRecursionInProtobufSchema(String fieldDescriptor)`
`static Throwable`	`funcBuildError(String funcName, Exception cause)`
`static Throwable`	`functionAlreadyExistsError(org.apache.spark.sql.catalyst.FunctionIdentifier func)`
`static Throwable`	`functionCannotProcessInputError(org.apache.spark.sql.connector.catalog.functions.UnboundFunction unbound, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> arguments, UnsupportedOperationException unsupported)`
`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 QueryContext[]`	`getQueryContext(org.apache.spark.sql.catalyst.trees.SQLQueryContext sqlContext)`
`static String`	`getSummary(org.apache.spark.sql.catalyst.trees.SQLQueryContext sqlContext)`
`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 tableName, String tableType)`
`static Throwable`	`hostOptionNotSetError()`
`static Throwable`	`identifierTooManyNamePartsError(String originalIdentifier)`
`static Throwable`	`illegalParquetTypeError(String parquetType)`
`static Throwable`	`incompatibleDataToTableAmbiguousColumnNameError(String tableName, String colName)`
`static Throwable`	`incompatibleDataToTableCannotFindDataError(String tableName, String colName)`
`static Throwable`	`incompatibleDataToTableCannotSafelyCastError(String tableName, String colName, String srcType, String targetType)`
`static Throwable`	`incompatibleDataToTableExtraColumnsError(String tableName, String extraColumns)`
`static Throwable`	`incompatibleDataToTableExtraStructFieldsError(String tableName, String colName, String extraFields)`
`static Throwable`	`incompatibleDataToTableNullableArrayElementsError(String tableName, String colName)`
`static Throwable`	`incompatibleDataToTableNullableColumnError(String tableName, String colName)`
`static Throwable`	`incompatibleDataToTableNullableMapValuesError(String tableName, String colName)`
`static Throwable`	`incompatibleDataToTableStructMissingFieldsError(String tableName, String colName, String missingFields)`
`static Throwable`	`incompatibleDataToTableUnexpectedColumnNameError(String tableName, String colName, int order, String expected, String found)`
`static Throwable`	`incompatibleViewSchemaChangeError(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`	`insufficientTablePropertyError(String key)`
`static Throwable`	`insufficientTablePropertyPartError(String key, String totalAmountOfParts)`
`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`	`invalidByteStringFormatError(Object unsupported)`
`static Throwable`	`invalidCoalesceHintParameterError(String hintName)`
`static Throwable`	`invalidColumnNameAsPathError(String datasource, String columnName)`
`static Throwable`	`invalidColumnOrFieldDataTypeError(scala.collection.Seq<String> name, DataType dt, DataType expected)`
`static Throwable`	`invalidDatabaseNameError(String quoted)`
`static Throwable`	`invalidDataSourceError(String className)`
`static Throwable`	`invalidEscapeChar(org.apache.spark.sql.catalyst.expressions.Expression sqlExpr)`
`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`	`invalidHintParameterError(String hintName, scala.collection.Seq<Object> invalidParams)`
`static Throwable`	`invalidIncludeTimestampValueError()`
`static Throwable`	`invalidJoinTypeInJoinWithError(org.apache.spark.sql.catalyst.plans.JoinType joinType)`
`static Throwable`	`invalidJsonSchema(DataType schema)`
`static Throwable`	`invalidLiteralForWindowDurationError()`
`static Throwable`	`invalidNameForTableOrDatabaseError(String name)`
`static Throwable`	`invalidOrderingForConstantValuePartitionColumnError(StructType targetPartitionSchema)`
`static Throwable`	`invalidPandasUDFPlacementError(scala.collection.Seq<String> groupAggPandasUDFNames)`
`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`	`invalidRepartitionExpressionsError(scala.collection.Seq<Object> sortOrders)`
`static Throwable`	`invalidRowLevelOperationAssignments(scala.collection.Seq<org.apache.spark.sql.catalyst.plans.logical.Assignment> assignments, scala.collection.Seq<String> errors)`
`static Throwable`	`invalidStarUsageError(String prettyName, scala.collection.Seq<org.apache.spark.sql.catalyst.analysis.Star> stars)`
`static Throwable`	`invalidTimestampExprForTimeTravel(String errorClass, org.apache.spark.sql.catalyst.expressions.Expression expr)`
`static Throwable`	`invalidTimestampProvidedForStrategyError(String strategy, String timeString)`
`static Throwable`	`invalidTimeTravelSpecError()`
`static Throwable`	`invalidViewNameError(String viewName)`
`static Throwable`	`invalidViewText(String viewText, String viewName)`
`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`	`lateralColumnAliasInAggFuncUnsupportedError(scala.collection.Seq<String> lcaNameParts, org.apache.spark.sql.catalyst.expressions.Expression aggExpr)`
`static Throwable`	`lateralColumnAliasInAggWithWindowAndHavingUnsupportedError(scala.collection.Seq<String> lcaNameParts)`
`static Throwable`	`lateralColumnAliasInWindowUnsupportedError(scala.collection.Seq<String> lcaNameParts, org.apache.spark.sql.catalyst.expressions.Expression windowExpr)`
`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`	`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`	`missingCatalogAbilityError(org.apache.spark.sql.connector.catalog.CatalogPlugin plugin, String ability)`
`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, org.apache.spark.sql.catalyst.trees.Origin origin)`
`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`	`namedArgumentsNotEnabledError(String functionName, String argumentName)`
`static Throwable`	`namedArgumentsNotSupported(String functionName)`
`static Throwable`	`namespaceAlreadyExistsError(String[] namespace)`
`static Throwable`	`nestedDatabaseUnsupportedByV1SessionCatalogError(String catalog)`
`static Throwable`	`nestedGeneratorError(org.apache.spark.sql.catalyst.expressions.Expression trimmedNestedGenerator)`
`static Throwable`	`noHandlerForUDAFError(String name)`
`static Throwable`	`nonBooleanFilterInAggregateError()`
`static Throwable`	`nonDeterministicFilterInAggregateError()`
`static Throwable`	`nonDeterministicMergeCondition(String condName, org.apache.spark.sql.catalyst.expressions.Expression cond)`
`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 org.apache.spark.sql.catalyst.analysis.NoSuchTableException`	`noSuchTableError(org.apache.spark.sql.connector.catalog.Identifier ident)`
`static Throwable`	`noSuchTableError(scala.collection.Seq<String> nameParts)`
`static Throwable`	`noSuchTableError(String db, String table)`
`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, org.apache.spark.sql.catalyst.expressions.Attribute attr)`
`static Throwable`	`notNullConstraintViolationArrayElementError(scala.collection.Seq<String> path)`
`static Throwable`	`notNullConstraintViolationMapValueError(scala.collection.Seq<String> path)`
`static Throwable`	`nullableColumnOrFieldError(scala.collection.Seq<String> name)`
`static Throwable`	`nullableRowIdError(scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.AttributeReference> nullableRowIdAttrs)`
`static Throwable`	`numberAndSizeOfPartitionsNotAllowedTogether()`
`static Throwable`	`numberOfPartitionsNotAllowedWithUnspecifiedDistributionError()`
`static Throwable`	`operationNotSupportPartitioningError(String operation)`
`static Throwable`	`optionMustBeConstant(String key, scala.Option<Throwable> cause)`
`static Throwable`	`optionMustBeLiteralString(String key)`
`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`	`partitionSizeNotAllowedWithUnspecifiedDistributionError()`
`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`	`positionalAndNamedArgumentDoubleReference(String functionName, String parameterName)`
`static Throwable`	`protobufClassLoadError(String protobufClassName, String explanation, Throwable cause)`
`static Throwable`	`protobufDescriptorDependencyError(String dependencyName)`
`static Throwable`	`protobufFieldMatchError(String field, String protobufSchema, String matchSize, String matches)`
`static Throwable`	`protobufFieldTypeMismatchError(String field)`
`static Throwable`	`protobufTypeUnsupportedYetError(String protobufType)`
`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(String fieldName, String[] fields)`
`static Throwable`	`renameTableSourceAndDestinationMismatchError(String db, String newDb)`
`static Throwable`	`renameTempViewToExistingViewError(String newName)`
`static Throwable`	`repairTableNotSupportedForV2TablesError()`
`static Throwable`	`requestedPartitionsMismatchTablePartitionsError(String tableName, scala.collection.immutable.Map<String,scala.Option<String>> normalizedPartSpec, StructType partColNames)`
`static Throwable`	`requiredParameterNotFound(String functionName, String parameterName, int index)`
`static Throwable`	`requireLiteralParameter(String funcName, String argName, String requiredType)`
`static Throwable`	`requiresSinglePartNamespaceError(scala.collection.Seq<String> namespace)`
`static AnalysisException`	`resolveException(String colName, String[] fields)`
`static Throwable`	`resourceTypeNotSupportedError(String resourceType)`
`static Throwable`	`saveDataIntoViewNotAllowedError()`
`static Throwable`	`schemaIsNotStructTypeError(org.apache.spark.sql.catalyst.expressions.Expression exp, DataType dataType)`
`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`	`sortByWithoutBucketingError()`
`static Throwable`	`sourceNotSupportedWithContinuousTriggerError(String source)`
`static Throwable`	`specifyPartitionNotAllowedWhenTableSchemaNotDefinedError()`
`static Throwable`	`starExpandDataTypeNotSupportedError(scala.collection.Seq<String> attributes)`
`static Throwable`	`starNotAllowedWhenGroupByOrdinalPositionUsedError()`
`static Throwable`	`staticPartitionInUserSpecifiedColumnsError(String staticName)`
`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`	`subqueryNotAllowedInMergeCondition(String condName, org.apache.spark.sql.catalyst.expressions.Expression cond)`
`static Throwable`	`tableAlreadyExistsError(org.apache.spark.sql.connector.catalog.Identifier ident)`
`static Throwable`	`tableAlreadyExistsError(String table)`
`static Throwable`	`tableAlreadyExistsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)`
`static Throwable`	`tableDoesNotSupportAtomicPartitionManagementError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`tableDoesNotSupportDeletesError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`tableDoesNotSupportPartitionManagementError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`tableDoesNotSupportReadsError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`tableDoesNotSupportTruncatesError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`tableDoesNotSupportWritesError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`tableIdentifierExistsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdentifier)`
`static Throwable`	`tableIdentifierNotConvertedToHadoopFsRelationError(org.apache.spark.sql.catalyst.TableIdentifier tableIdentifier)`
`static Throwable`	`tableIndexNotSupportedError(String errorMessage)`
`static Throwable`	`tableIsNotRowLevelOperationTableError(org.apache.spark.sql.connector.catalog.Table table)`
`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, org.apache.spark.sql.connector.catalog.Table t)`
`static Throwable`	`tableOrViewAlreadyExistsError(String name)`
`static Throwable`	`tableOrViewNotFound(scala.collection.Seq<String> ident)`
`static Throwable`	`tableValuedFunctionTooManyTableArgumentsError(int num)`
`static Throwable`	`tempViewNotCachedForAnalyzingColumnsError(org.apache.spark.sql.catalyst.TableIdentifier tableIdent)`
`static Throwable`	`tempViewNotSupportStreamingWriteError(String viewName)`
`static Throwable`	`textDataSourceWithMultiColumnsError(StructType schema)`
`static Throwable`	`timeTravelUnsupportedError(String relationId)`
`static String`	`toDSOption(String option)`
`static String`	`toSQLConf(String conf)`
`static String`	`toSQLConfVal(String conf)`
`static String`	`toSQLExpr(org.apache.spark.sql.catalyst.expressions.Expression e)`
`static String`	`toSQLId(scala.collection.Seq<String> parts)`
`static String`	`toSQLId(String parts)`
`static String`	`toSQLSchema(String schema)`
`static String`	`toSQLStmt(String text)`
`static String`	`toSQLType(org.apache.spark.sql.types.AbstractDataType t)`
`static String`	`toSQLType(String text)`
`static String`	`toSQLValue(double value)`
`static String`	`toSQLValue(float value)`
`static String`	`toSQLValue(int value)`
`static String`	`toSQLValue(long value)`
`static String`	`toSQLValue(Object v, DataType t)`
`static String`	`toSQLValue(short value)`
`static String`	`toSQLValue(String value)`
`static String`	`toSQLValue(org.apache.spark.unsafe.types.UTF8String value)`
`static Throwable`	`truncateTableOnExternalTablesError(String tableIdentWithDB)`
`static Throwable`	`truncateTablePartitionNotSupportedForNotPartitionedTablesError(String tableIdentWithDB)`
`static Throwable`	`udfClassDoesNotImplementAnyUDFInterfaceError(String className)`
`static Throwable`	`udfClassImplementMultiUDFInterfacesError(String className)`
`static Throwable`	`udfClassWithTooManyTypeArgumentsError(int n)`
`static Throwable`	`unableToLocateProtobufMessageError(String messageName)`
`static Throwable`	`unexpectedInputDataTypeError(String functionName, int paramIndex, DataType dataType, org.apache.spark.sql.catalyst.expressions.Expression expression)`
`static Throwable`	`unexpectedPartitionColumnPrefixError(String table, String database, String schemaColumns, String specColumns)`
`static Throwable`	`unexpectedPositionalArgument(String functionName, String precedingNamedArgument)`
`static Throwable`	`unexpectedRequiredParameterInFunctionSignature(String functionName, org.apache.spark.sql.catalyst.plans.logical.FunctionSignature functionSignature)`
`static Throwable`	`unexpectedSchemaTypeError(org.apache.spark.sql.catalyst.expressions.Expression exp)`
`static Throwable`	`unknownHiveResourceTypeError(String resourceType)`
`static Throwable`	`unknownProtobufMessageTypeError(String descriptorName, String containingType)`
`static Throwable`	`unorderablePivotColError(org.apache.spark.sql.catalyst.expressions.Expression pivotCol)`
`static Throwable`	`unpivotRequiresAttributes(String given, String empty, scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.NamedExpression> expressions)`
`static Throwable`	`unpivotRequiresValueColumns()`
`static Throwable`	`unpivotValueDataTypeMismatchError(scala.collection.Seq<scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.NamedExpression>> values)`
`static Throwable`	`unpivotValueSizeMismatchError(int names)`
`static Throwable`	`unrecognizedParameterName(String functionName, String argumentName, scala.collection.Seq<String> candidates)`
`static Throwable`	`unrecognizedParquetTypeError(String field)`
`static Throwable`	`unresolvedAttributeError(String errorClass, String colName, scala.collection.Seq<String> candidates, org.apache.spark.sql.catalyst.trees.Origin origin)`
`static Throwable`	`unresolvedColumnError(String columnName, scala.collection.Seq<String> proposal)`
`static AnalysisException`	`unresolvedColumnWithSuggestionError(String objectName, String suggestion)`
`static Throwable`	`unresolvedFieldError(String fieldName, scala.collection.Seq<String> columnPath, scala.collection.Seq<String> proposal)`
`static Throwable`	`unresolvedRoutineError(org.apache.spark.sql.catalyst.FunctionIdentifier name, scala.collection.Seq<String> searchPath)`
`static Throwable`	`unresolvedRoutineError(scala.collection.Seq<String> nameParts, scala.collection.Seq<String> searchPath, org.apache.spark.sql.catalyst.trees.Origin context)`
`static Throwable`	`unresolvedUsingColForJoinError(String colName, String suggestion, String side)`
`static Throwable`	`unsetNonExistentPropertiesError(scala.collection.Seq<String> properties, org.apache.spark.sql.catalyst.TableIdentifier table)`
`static Throwable`	`unsupportedAppendInBatchModeError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`unsupportedBatchReadError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`unsupportedCorrelatedReferenceDataTypeError(org.apache.spark.sql.catalyst.expressions.Expression expr, DataType dataType, org.apache.spark.sql.catalyst.trees.Origin origin)`
`static Throwable`	`unsupportedDeleteByConditionWithSubqueryError(org.apache.spark.sql.catalyst.expressions.Expression condition)`
`static Throwable`	`unsupportedDynamicOverwriteInBatchModeError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`unsupportedIfNotExistsError(String tableName)`
`static Throwable`	`unsupportedJDBCNamespaceChangeInCatalogError(scala.collection.Seq<org.apache.spark.sql.connector.catalog.NamespaceChange> changes)`
`static Throwable`	`unsupportedMicroBatchOrContinuousScanError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`unsupportedOverwriteByFilterInBatchModeError(org.apache.spark.sql.connector.catalog.Table table)`
`static Throwable`	`unsupportedTableChangeInJDBCCatalogError(org.apache.spark.sql.connector.catalog.TableChange change)`
`static Throwable`	`unsupportedTableOperationError(org.apache.spark.sql.connector.catalog.CatalogPlugin catalog, org.apache.spark.sql.connector.catalog.Identifier ident, String operation)`
`static Throwable`	`unsupportedTableOperationError(org.apache.spark.sql.catalyst.TableIdentifier ident, String operation)`
`static Throwable`	`unsupportedTruncateInBatchModeError(org.apache.spark.sql.connector.catalog.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(org.apache.spark.sql.connector.catalog.functions.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`	`windowAggregateFunctionWithFilterNotSupportedError()`
`static Throwable`	`windowFrameNotMatchRequiredFrameError(org.apache.spark.sql.catalyst.expressions.SpecifiedWindowFrame f, org.apache.spark.sql.catalyst.expressions.WindowFrame required)`
`static Throwable`	`windowFunctionInAggregateFilterError()`
`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`	`writeDistributionAndOrderingNotSupportedInContinuousExecution()`
`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`	`writeWithSaveModeUnsupportedBySourceError(String source, String createMode)`
`static Throwable`	`wrongCommandForObjectTypeError(String operation, String requiredType, String objectName, String foundType, String alternative)`
`static Throwable`	`wrongNumArgsError(String name, scala.collection.Seq<Object> validParametersCount, int actualNumber, String legacyNum, String legacyConfKey, String legacyConfValue)`
`static Throwable`	`zeroArgumentIndexError()`

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

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

Method Detail

unexpectedRequiredParameterInFunctionSignature

public static Throwable unexpectedRequiredParameterInFunctionSignature(String functionName,
                                                                       org.apache.spark.sql.catalyst.plans.logical.FunctionSignature functionSignature)

namedArgumentsNotSupported

public static Throwable namedArgumentsNotSupported(String functionName)

positionalAndNamedArgumentDoubleReference

public static Throwable positionalAndNamedArgumentDoubleReference(String functionName,
                                                                  String parameterName)

doubleNamedArgumentReference

public static Throwable doubleNamedArgumentReference(String functionName,
                                                     String parameterName)

requiredParameterNotFound

public static Throwable requiredParameterNotFound(String functionName,
                                                  String parameterName,
                                                  int index)

unrecognizedParameterName

public static Throwable unrecognizedParameterName(String functionName,
                                                  String argumentName,
                                                  scala.collection.Seq<String> candidates)

unexpectedPositionalArgument

public static Throwable unexpectedPositionalArgument(String functionName,
                                                     String precedingNamedArgument)

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)

zeroArgumentIndexError

public static Throwable zeroArgumentIndexError()

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)

unpivotRequiresAttributes

public static Throwable unpivotRequiresAttributes(String given,
                                                  String empty,
                                                  scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.NamedExpression> expressions)

unpivotRequiresValueColumns

public static Throwable unpivotRequiresValueColumns()

unpivotValueSizeMismatchError

public static Throwable unpivotValueSizeMismatchError(int names)

unpivotValueDataTypeMismatchError

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

unsupportedIfNotExistsError

public static Throwable unsupportedIfNotExistsError(String tableName)

nonPartitionColError

public static Throwable nonPartitionColError(String partitionName)

missingStaticPartitionColumn

public static Throwable missingStaticPartitionColumn(String staticName)

staticPartitionInUserSpecifiedColumnsError

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

namedArgumentsNotEnabledError

public static Throwable namedArgumentsNotEnabledError(String functionName,
                                                      String argumentName)

unresolvedUsingColForJoinError

public static Throwable unresolvedUsingColForJoinError(String colName,
                                                       String suggestion,
                                                       String side)

unresolvedAttributeError

public static Throwable unresolvedAttributeError(String errorClass,
                                                 String colName,
                                                 scala.collection.Seq<String> candidates,
                                                 org.apache.spark.sql.catalyst.trees.Origin origin)

unresolvedColumnError

public static Throwable unresolvedColumnError(String columnName,
                                              scala.collection.Seq<String> proposal)

unresolvedFieldError

public static Throwable unresolvedFieldError(String fieldName,
                                             scala.collection.Seq<String> columnPath,
                                             scala.collection.Seq<String> proposal)

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)

outerScopeFailureForNewInstanceError

public static Throwable outerScopeFailureForNewInstanceError(String className)

referenceColNotFoundForAlterTableChangesError

public static Throwable referenceColNotFoundForAlterTableChangesError(String fieldName,
                                                                      String[] fields)

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)

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(scala.collection.Seq<String> nameParts,
                                                boolean isTemp,
                                                String cmd,
                                                scala.Option<String> mismatchHint,
                                                org.apache.spark.sql.catalyst.trees.TreeNode<?> t)

expectViewNotTempViewError

public static Throwable expectViewNotTempViewError(scala.collection.Seq<String> nameParts,
                                                   String cmd,
                                                   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)

expectTableOrPermanentViewNotTempViewError

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

expectPersistentFuncError

public static Throwable expectPersistentFuncError(String name,
                                                  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,
                                              scala.collection.Seq<org.apache.spark.sql.catalyst.analysis.Star> stars)

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

nonBooleanFilterInAggregateError

public static Throwable nonBooleanFilterInAggregateError()

aggregateInAggregateFilterError

public static Throwable aggregateInAggregateFilterError()

windowFunctionInAggregateFilterError

public static Throwable windowFunctionInAggregateFilterError()

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)

multiTimeWindowExpressionsNotSupportedError

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

sessionWindowGapDurationDataTypeError

public static Throwable sessionWindowGapDurationDataTypeError(DataType dt)

unresolvedRoutineError

public static Throwable unresolvedRoutineError(org.apache.spark.sql.catalyst.FunctionIdentifier name,
                                               scala.collection.Seq<String> searchPath)

unresolvedRoutineError

public static Throwable unresolvedRoutineError(scala.collection.Seq<String> nameParts,
                                               scala.collection.Seq<String> searchPath,
                                               org.apache.spark.sql.catalyst.trees.Origin context)

wrongNumArgsError

public static Throwable wrongNumArgsError(String name,
                                          scala.collection.Seq<Object> validParametersCount,
                                          int actualNumber,
                                          String legacyNum,
                                          String legacyConfKey,
                                          String legacyConfValue)

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

unsupportedTableOperationError

public static Throwable unsupportedTableOperationError(org.apache.spark.sql.connector.catalog.CatalogPlugin catalog,
                                                       org.apache.spark.sql.connector.catalog.Identifier ident,
                                                       String operation)

unsupportedTableOperationError

public static Throwable unsupportedTableOperationError(org.apache.spark.sql.catalyst.TableIdentifier ident,
                                                       String operation)

catalogOperationNotSupported

public static Throwable catalogOperationNotSupported(org.apache.spark.sql.connector.catalog.CatalogPlugin catalog,
                                                     String operation)

alterColumnWithV1TableCannotSpecifyNotNullError

public static Throwable alterColumnWithV1TableCannotSpecifyNotNullError()

alterColumnCannotFindColumnInV1TableError

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

invalidDatabaseNameError

public static Throwable invalidDatabaseNameError(String quoted)

wrongCommandForObjectTypeError

public static Throwable wrongCommandForObjectTypeError(String operation,
                                                       String requiredType,
                                                       String objectName,
                                                       String foundType,
                                                       String alternative)

showColumnsWithConflictDatabasesError

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

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)

renameTempViewToExistingViewError

public static Throwable renameTempViewToExistingViewError(String newName)

cannotDropNonemptyDatabaseError

public static Throwable cannotDropNonemptyDatabaseError(String db)

cannotDropNonemptyNamespaceError

public static Throwable cannotDropNonemptyNamespaceError(scala.collection.Seq<String> namespace)

invalidNameForTableOrDatabaseError

public static Throwable invalidNameForTableOrDatabaseError(String name)

cannotCreateDatabaseWithSameNameAsPreservedDatabaseError

public static Throwable cannotCreateDatabaseWithSameNameAsPreservedDatabaseError(String database)

cannotDropDefaultDatabaseError

public static Throwable cannotDropDefaultDatabaseError(String database)

cannotUsePreservedDatabaseAsCurrentDatabaseError

public static Throwable cannotUsePreservedDatabaseAsCurrentDatabaseError(String database)

createExternalTableWithoutLocationError

public static Throwable createExternalTableWithoutLocationError()

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

insufficientTablePropertyError

public static Throwable insufficientTablePropertyError(String key)

insufficientTablePropertyPartError

public static Throwable insufficientTablePropertyPartError(String key,
                                                           String totalAmountOfParts)

unexpectedSchemaTypeError

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

schemaIsNotStructTypeError

public static Throwable schemaIsNotStructTypeError(org.apache.spark.sql.catalyst.expressions.Expression exp,
                                                   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)

requireLiteralParameter

public static Throwable requireLiteralParameter(String funcName,
                                                String argName,
                                                String requiredType)

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(org.apache.spark.sql.connector.catalog.Table table,
                                                  String v2WriteClassName,
                                                  String v1WriteClassName)

unsupportedDeleteByConditionWithSubqueryError

public static Throwable unsupportedDeleteByConditionWithSubqueryError(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(org.apache.spark.sql.connector.catalog.Table table,
                                                           org.apache.spark.sql.connector.expressions.filter.Predicate[] filters)

describeDoesNotSupportPartitionForV2TablesError

public static Throwable describeDoesNotSupportPartitionForV2TablesError()

cannotReplaceMissingTableError

public static Throwable cannotReplaceMissingTableError(org.apache.spark.sql.connector.catalog.Identifier tableIdentifier)

cannotReplaceMissingTableError

public static Throwable cannotReplaceMissingTableError(org.apache.spark.sql.connector.catalog.Identifier tableIdentifier,
                                                       scala.Option<Throwable> cause)

unsupportedBatchReadError

public static Throwable unsupportedBatchReadError(org.apache.spark.sql.connector.catalog.Table table)

unsupportedMicroBatchOrContinuousScanError

public static Throwable unsupportedMicroBatchOrContinuousScanError(org.apache.spark.sql.connector.catalog.Table table)

unsupportedAppendInBatchModeError

public static Throwable unsupportedAppendInBatchModeError(org.apache.spark.sql.connector.catalog.Table table)

unsupportedDynamicOverwriteInBatchModeError

public static Throwable unsupportedDynamicOverwriteInBatchModeError(org.apache.spark.sql.connector.catalog.Table table)

unsupportedTruncateInBatchModeError

public static Throwable unsupportedTruncateInBatchModeError(org.apache.spark.sql.connector.catalog.Table table)

unsupportedOverwriteByFilterInBatchModeError

public static Throwable unsupportedOverwriteByFilterInBatchModeError(org.apache.spark.sql.connector.catalog.Table table)

streamingSourcesDoNotSupportCommonExecutionModeError

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

noSuchTableError

public static org.apache.spark.sql.catalyst.analysis.NoSuchTableException noSuchTableError(org.apache.spark.sql.connector.catalog.Identifier ident)

noSuchTableError

public static Throwable noSuchTableError(scala.collection.Seq<String> nameParts)

noSuchNamespaceError

public static Throwable noSuchNamespaceError(String[] namespace)

tableAlreadyExistsError

public static Throwable tableAlreadyExistsError(org.apache.spark.sql.connector.catalog.Identifier ident)

requiresSinglePartNamespaceError

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

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

cannotSetJDBCNamespaceWithPropertyError

public static Throwable cannotSetJDBCNamespaceWithPropertyError(String property)

cannotUnsetJDBCNamespaceWithPropertyError

public static Throwable cannotUnsetJDBCNamespaceWithPropertyError(String property)

unsupportedJDBCNamespaceChangeInCatalogError

public static Throwable unsupportedJDBCNamespaceChangeInCatalogError(scala.collection.Seq<org.apache.spark.sql.connector.catalog.NamespaceChange> changes)

tableDoesNotSupportReadsError

public static Throwable tableDoesNotSupportReadsError(org.apache.spark.sql.connector.catalog.Table table)

tableDoesNotSupportWritesError

public static Throwable tableDoesNotSupportWritesError(org.apache.spark.sql.connector.catalog.Table table)

tableDoesNotSupportDeletesError

public static Throwable tableDoesNotSupportDeletesError(org.apache.spark.sql.connector.catalog.Table table)

tableDoesNotSupportTruncatesError

public static Throwable tableDoesNotSupportTruncatesError(org.apache.spark.sql.connector.catalog.Table table)

tableDoesNotSupportPartitionManagementError

public static Throwable tableDoesNotSupportPartitionManagementError(org.apache.spark.sql.connector.catalog.Table table)

tableDoesNotSupportAtomicPartitionManagementError

public static Throwable tableDoesNotSupportAtomicPartitionManagementError(org.apache.spark.sql.connector.catalog.Table table)

tableIsNotRowLevelOperationTableError

public static Throwable tableIsNotRowLevelOperationTableError(org.apache.spark.sql.connector.catalog.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 column)

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)

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)

requestedPartitionsMismatchTablePartitionsError

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

ddlWithoutHiveSupportEnabledError

public static Throwable ddlWithoutHiveSupportEnabledError(String cmd)

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)

incompatibleViewSchemaChangeError

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

partitionSizeNotAllowedWithUnspecifiedDistributionError

public static Throwable partitionSizeNotAllowedWithUnspecifiedDistributionError()

numberAndSizeOfPartitionsNotAllowedTogether

public static Throwable numberAndSizeOfPartitionsNotAllowedTogether()

unexpectedInputDataTypeError

public static Throwable unexpectedInputDataTypeError(String functionName,
                                                     int paramIndex,
                                                     DataType dataType,
                                                     org.apache.spark.sql.catalyst.expressions.Expression expression)

streamJoinStreamWithoutEqualityPredicateUnsupportedError

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

invalidPandasUDFPlacementError

public static Throwable invalidPandasUDFPlacementError(scala.collection.Seq<String> groupAggPandasUDFNames)

ambiguousAttributesInSelfJoinError

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

ambiguousColumnOrFieldError

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

ambiguousReferenceError

public static Throwable ambiguousReferenceError(String name,
                                                scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> ambiguousReferences)

cannotUseIntervalTypeInTableSchemaError

public static Throwable cannotUseIntervalTypeInTableSchemaError()

missingCatalogAbilityError

public static Throwable missingCatalogAbilityError(org.apache.spark.sql.connector.catalog.CatalogPlugin plugin,
                                                   String ability)

tableValuedFunctionTooManyTableArgumentsError

public static Throwable tableValuedFunctionTooManyTableArgumentsError(int num)

identifierTooManyNamePartsError

public static Throwable identifierTooManyNamePartsError(String originalIdentifier)

emptyMultipartIdentifierError

public static Throwable emptyMultipartIdentifierError()

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,
                                                           org.apache.spark.sql.connector.catalog.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,
                                           org.apache.spark.sql.catalyst.trees.Origin origin)

unsupportedCorrelatedReferenceDataTypeError

public static Throwable unsupportedCorrelatedReferenceDataTypeError(org.apache.spark.sql.catalyst.expressions.Expression expr,
                                                                    DataType dataType,
                                                                    org.apache.spark.sql.catalyst.trees.Origin origin)

functionCannotProcessInputError

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

v2FunctionInvalidInputTypeLengthError

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

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<String> expected,
                                                              scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> queryOutput)

cannotWriteNotEnoughColumnsToTableError

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

incompatibleDataToTableCannotFindDataError

public static Throwable incompatibleDataToTableCannotFindDataError(String tableName,
                                                                   String colName)

incompatibleDataToTableAmbiguousColumnNameError

public static Throwable incompatibleDataToTableAmbiguousColumnNameError(String tableName,
                                                                        String colName)

incompatibleDataToTableExtraColumnsError

public static Throwable incompatibleDataToTableExtraColumnsError(String tableName,
                                                                 String extraColumns)

incompatibleDataToTableExtraStructFieldsError

public static Throwable incompatibleDataToTableExtraStructFieldsError(String tableName,
                                                                      String colName,
                                                                      String extraFields)

incompatibleDataToTableNullableColumnError

public static Throwable incompatibleDataToTableNullableColumnError(String tableName,
                                                                   String colName)

incompatibleDataToTableNullableArrayElementsError

public static Throwable incompatibleDataToTableNullableArrayElementsError(String tableName,
                                                                          String colName)

incompatibleDataToTableNullableMapValuesError

public static Throwable incompatibleDataToTableNullableMapValuesError(String tableName,
                                                                      String colName)

incompatibleDataToTableCannotSafelyCastError

public static Throwable incompatibleDataToTableCannotSafelyCastError(String tableName,
                                                                     String colName,
                                                                     String srcType,
                                                                     String targetType)

incompatibleDataToTableStructMissingFieldsError

public static Throwable incompatibleDataToTableStructMissingFieldsError(String tableName,
                                                                        String colName,
                                                                        String missingFields)

incompatibleDataToTableUnexpectedColumnNameError

public static Throwable incompatibleDataToTableUnexpectedColumnNameError(String tableName,
                                                                         String colName,
                                                                         int order,
                                                                         String expected,
                                                                         String found)

invalidRowLevelOperationAssignments

public static Throwable invalidRowLevelOperationAssignments(scala.collection.Seq<org.apache.spark.sql.catalyst.plans.logical.Assignment> assignments,
                                                            scala.collection.Seq<String> errors)

invalidEscapeChar

public static Throwable invalidEscapeChar(org.apache.spark.sql.catalyst.expressions.Expression sqlExpr)

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 field,
                                                        int numberOfAppearance)

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

escapeCharacterInTheMiddleError

public static Throwable escapeCharacterInTheMiddleError(String pattern,
                                                        String char_)

escapeCharacterAtTheEndError

public static Throwable escapeCharacterAtTheEndError(String pattern)

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

hiveTableTypeUnsupportedError

public static Throwable hiveTableTypeUnsupportedError(String tableName,
                                                      String tableType)

hiveCreatePermanentFunctionsUnsupportedError

public static Throwable hiveCreatePermanentFunctionsUnsupportedError()

unknownHiveResourceTypeError

public static Throwable unknownHiveResourceTypeError(String resourceType)

configRemovedInVersionError

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

invalidPartitionColumnKeyInTableError

public static Throwable invalidPartitionColumnKeyInTableError(String key,
                                                              String tblName)

invalidPartitionSpecError

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

columnAlreadyExistsError

public static Throwable columnAlreadyExistsError(String columnName)

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)

createTableAsSelectWithNonEmptyDirectoryError

public static Throwable createTableAsSelectWithNonEmptyDirectoryError(String tablePath)

unsetNonExistentPropertiesError

public static Throwable unsetNonExistentPropertiesError(scala.collection.Seq<String> properties,
                                                        org.apache.spark.sql.catalyst.TableIdentifier table)

alterTableChangeColumnNotSupportedForColumnTypeError

public static Throwable alterTableChangeColumnNotSupportedForColumnTypeError(String tableName,
                                                                             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 operation,
                                                             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(String path)

cannotOverwriteTableThatIsBeingReadFromError

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

cannotDropBuiltinFuncError

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

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)

logicalPlanForViewNotAnalyzedError

public static Throwable logicalPlanForViewNotAnalyzedError()

cannotCreateViewTooManyColumnsError

public static Throwable cannotCreateViewTooManyColumnsError(org.apache.spark.sql.catalyst.TableIdentifier viewIdent,
                                                            scala.collection.Seq<String> expected,
                                                            org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)

cannotCreateViewNotEnoughColumnsError

public static Throwable cannotCreateViewNotEnoughColumnsError(org.apache.spark.sql.catalyst.TableIdentifier viewIdent,
                                                              scala.collection.Seq<String> expected,
                                                              org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query)

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,
                                                                                               org.apache.spark.sql.catalyst.expressions.Attribute attr)

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)

invalidColumnNameAsPathError

public static Throwable invalidColumnNameAsPathError(String datasource,
                                                     String columnName)

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)

tableOrViewNotFound

public static Throwable tableOrViewNotFound(scala.collection.Seq<String> ident)

unsupportedTableChangeInJDBCCatalogError

public static Throwable unsupportedTableChangeInJDBCCatalogError(org.apache.spark.sql.connector.catalog.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)

sortByWithoutBucketingError

public static Throwable sortByWithoutBucketingError()

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)

invalidPartitionTransformationError

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

unresolvedColumnWithSuggestionError

public static AnalysisException unresolvedColumnWithSuggestionError(String objectName,
                                                                    String suggestion)

resolveException

public static AnalysisException resolveException(String colName,
                                                 String[] fields)

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,
                                                            String docroot)

commandExecutionInRunnerUnsupportedError

public static Throwable commandExecutionInRunnerUnsupportedError(String runner)

udfClassDoesNotImplementAnyUDFInterfaceError

public static Throwable udfClassDoesNotImplementAnyUDFInterfaceError(String className)

udfClassImplementMultiUDFInterfacesError

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

invalidJsonSchema

public static Throwable invalidJsonSchema(DataType schema)

tableIndexNotSupportedError

public static Throwable tableIndexNotSupportedError(String errorMessage)

invalidViewText

public static Throwable invalidViewText(String viewText,
                                        String viewName)

invalidTimeTravelSpecError

public static Throwable invalidTimeTravelSpecError()

invalidTimestampExprForTimeTravel

public static Throwable invalidTimestampExprForTimeTravel(String errorClass,
                                                          org.apache.spark.sql.catalyst.expressions.Expression expr)

timeTravelUnsupportedError

public static Throwable timeTravelUnsupportedError(String relationId)

writeDistributionAndOrderingNotSupportedInContinuousExecution

public static Throwable writeDistributionAndOrderingNotSupportedInContinuousExecution()

defaultReferencesNotAllowedInComplexExpressionsInInsertValuesList

public static Throwable defaultReferencesNotAllowedInComplexExpressionsInInsertValuesList()

defaultReferencesNotAllowedInComplexExpressionsInUpdateSetClause

public static Throwable defaultReferencesNotAllowedInComplexExpressionsInUpdateSetClause()

defaultReferencesNotAllowedInComplexExpressionsInMergeInsertsOrUpdates

public static Throwable defaultReferencesNotAllowedInComplexExpressionsInMergeInsertsOrUpdates()

nonDeterministicMergeCondition

public static Throwable nonDeterministicMergeCondition(String condName,
                                                       org.apache.spark.sql.catalyst.expressions.Expression cond)

subqueryNotAllowedInMergeCondition

public static Throwable subqueryNotAllowedInMergeCondition(String condName,
                                                           org.apache.spark.sql.catalyst.expressions.Expression cond)

aggregationNotAllowedInMergeCondition

public static Throwable aggregationNotAllowedInMergeCondition(String condName,
                                                              org.apache.spark.sql.catalyst.expressions.Expression cond)

failedToParseExistenceDefaultAsLiteral

public static Throwable failedToParseExistenceDefaultAsLiteral(String fieldName,
                                                               String defaultValue)

defaultReferencesNotAllowedInDataSource

public static Throwable defaultReferencesNotAllowedInDataSource(String statementType,
                                                                String dataSource)

addNewDefaultColumnToExistingTableNotAllowed

public static Throwable addNewDefaultColumnToExistingTableNotAllowed(String statementType,
                                                                     String dataSource)

defaultValuesDataTypeError

public static Throwable defaultValuesDataTypeError(String statement,
                                                   String colName,
                                                   String defaultValue,
                                                   DataType expectedType,
                                                   DataType actualType)

defaultValuesUnresolvedExprError

public static Throwable defaultValuesUnresolvedExprError(String statement,
                                                         String colName,
                                                         String defaultValue,
                                                         Throwable cause)

defaultValuesMayNotContainSubQueryExpressions

public static Throwable defaultValuesMayNotContainSubQueryExpressions(String statement,
                                                                      String colName,
                                                                      String defaultValue)

nullableColumnOrFieldError

public static Throwable nullableColumnOrFieldError(scala.collection.Seq<String> name)

notNullConstraintViolationArrayElementError

public static Throwable notNullConstraintViolationArrayElementError(scala.collection.Seq<String> path)

notNullConstraintViolationMapValueError

public static Throwable notNullConstraintViolationMapValueError(scala.collection.Seq<String> path)

invalidColumnOrFieldDataTypeError

public static Throwable invalidColumnOrFieldDataTypeError(scala.collection.Seq<String> name,
                                                          DataType dt,
                                                          DataType expected)

columnNotInGroupByClauseError

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

cannotConvertProtobufTypeToSqlTypeError

public static Throwable cannotConvertProtobufTypeToSqlTypeError(String protobufColumn,
                                                                scala.collection.Seq<String> sqlColumn,
                                                                String protobufType,
                                                                DataType sqlType)

cannotConvertCatalystTypeToProtobufTypeError

public static Throwable cannotConvertCatalystTypeToProtobufTypeError(scala.collection.Seq<String> sqlColumn,
                                                                     String protobufColumn,
                                                                     DataType sqlType,
                                                                     String protobufType)

cannotConvertProtobufTypeToCatalystTypeError

public static Throwable cannotConvertProtobufTypeToCatalystTypeError(String protobufType,
                                                                     DataType sqlType,
                                                                     Throwable cause)

cannotConvertSqlTypeToProtobufError

public static Throwable cannotConvertSqlTypeToProtobufError(String protobufType,
                                                            DataType sqlType,
                                                            Throwable cause)

protobufTypeUnsupportedYetError

public static Throwable protobufTypeUnsupportedYetError(String protobufType)

unknownProtobufMessageTypeError

public static Throwable unknownProtobufMessageTypeError(String descriptorName,
                                                        String containingType)

cannotFindCatalystTypeInProtobufSchemaError

public static Throwable cannotFindCatalystTypeInProtobufSchemaError(String catalystFieldPath)

cannotFindProtobufFieldInCatalystError

public static Throwable cannotFindProtobufFieldInCatalystError(String field)

protobufFieldMatchError

public static Throwable protobufFieldMatchError(String field,
                                                String protobufSchema,
                                                String matchSize,
                                                String matches)

unableToLocateProtobufMessageError

public static Throwable unableToLocateProtobufMessageError(String messageName)

foundRecursionInProtobufSchema

public static Throwable foundRecursionInProtobufSchema(String fieldDescriptor)

protobufFieldTypeMismatchError

public static Throwable protobufFieldTypeMismatchError(String field)

protobufClassLoadError

public static Throwable protobufClassLoadError(String protobufClassName,
                                               String explanation,
                                               Throwable cause)

protobufDescriptorDependencyError

public static Throwable protobufDescriptorDependencyError(String dependencyName)

invalidByteStringFormatError

public static Throwable invalidByteStringFormatError(Object unsupported)

funcBuildError

public static Throwable funcBuildError(String funcName,
                                       Exception cause)

ambiguousRelationAliasNameInNestedCTEError

public static Throwable ambiguousRelationAliasNameInNestedCTEError(String name)

ambiguousLateralColumnAliasError

public static Throwable ambiguousLateralColumnAliasError(String name,
                                                         int numOfMatches)

ambiguousLateralColumnAliasError

public static Throwable ambiguousLateralColumnAliasError(scala.collection.Seq<String> nameParts,
                                                         int numOfMatches)

lateralColumnAliasInAggFuncUnsupportedError

public static Throwable lateralColumnAliasInAggFuncUnsupportedError(scala.collection.Seq<String> lcaNameParts,
                                                                    org.apache.spark.sql.catalyst.expressions.Expression aggExpr)

lateralColumnAliasInWindowUnsupportedError

public static Throwable lateralColumnAliasInWindowUnsupportedError(scala.collection.Seq<String> lcaNameParts,
                                                                   org.apache.spark.sql.catalyst.expressions.Expression windowExpr)

lateralColumnAliasInAggWithWindowAndHavingUnsupportedError

public static Throwable lateralColumnAliasInAggWithWindowAndHavingUnsupportedError(scala.collection.Seq<String> lcaNameParts)

dataTypeOperationUnsupportedError

public static Throwable dataTypeOperationUnsupportedError()

nullableRowIdError

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

cannotRenameTableAcrossSchemaError

public static Throwable cannotRenameTableAcrossSchemaError()

optionMustBeLiteralString

public static Throwable optionMustBeLiteralString(String key)

optionMustBeConstant

public static Throwable optionMustBeConstant(String key,
                                             scala.Option<Throwable> cause)

toSQLId

public static String toSQLId(String parts)

toSQLId

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

toSQLStmt

public static String toSQLStmt(String text)

toSQLConf

public static String toSQLConf(String conf)

toSQLType

public static String toSQLType(String text)

toSQLType

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

toSQLValue

public static String toSQLValue(String value)

toSQLValue

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

toSQLValue

public static String toSQLValue(short value)

toSQLValue

public static String toSQLValue(int value)

toSQLValue

public static String toSQLValue(long value)

toSQLValue

public static String toSQLValue(float value)

toSQLValue

public static String toSQLValue(double value)

getSummary

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

getQueryContext

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

toSQLConfVal

public static String toSQLConfVal(String conf)

toDSOption

public static String toDSOption(String option)

toSQLExpr

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

toSQLSchema

public static String toSQLSchema(String schema)

toSQLValue

public static String toSQLValue(Object v,
                                DataType t)

columnNotFoundError

public static AnalysisException columnNotFoundError(String colName)

descriptorParseError

public static AnalysisException descriptorParseError(Throwable cause)

cannotFindDescriptorFileError

public static AnalysisException cannotFindDescriptorFileError(String filePath,
                                                              Throwable cause)

Class QueryCompilationErrors

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

QueryCompilationErrors

Method Detail

unexpectedRequiredParameterInFunctionSignature

namedArgumentsNotSupported

positionalAndNamedArgumentDoubleReference

doubleNamedArgumentReference

requiredParameterNotFound

unrecognizedParameterName

unexpectedPositionalArgument

groupingIDMismatchError

groupingColInvalidError

groupingSizeTooLargeError

zeroArgumentIndexError

unorderablePivotColError

nonLiteralPivotValError

pivotValDataTypeMismatchError

unpivotRequiresAttributes

unpivotRequiresValueColumns

unpivotValueSizeMismatchError

unpivotValueDataTypeMismatchError

unsupportedIfNotExistsError

nonPartitionColError

missingStaticPartitionColumn

staticPartitionInUserSpecifiedColumnsError

nestedGeneratorError

moreThanOneGeneratorError

generatorOutsideSelectError

legacyStoreAssignmentPolicyError

namedArgumentsNotEnabledError

unresolvedUsingColForJoinError

unresolvedAttributeError

unresolvedColumnError

unresolvedFieldError

dataTypeMismatchForDeserializerError

fieldNumberMismatchForDeserializerError

upCastFailureError

outerScopeFailureForNewInstanceError

referenceColNotFoundForAlterTableChangesError

windowSpecificationNotDefinedError

selectExprNotInGroupByError

groupingMustWithGroupingSetsOrCubeOrRollupError

pandasUDFAggregateNotSupportedInPivotError

aggregateExpressionRequiredForPivotError

writeIntoTempViewNotAllowedError

readNonStreamingTempViewError

viewDepthExceedsMaxResolutionDepthError

insertIntoViewNotAllowedError

writeIntoViewNotAllowedError

writeIntoV1TableNotAllowedError

expectTableNotViewError

expectViewNotTempViewError

expectViewNotTableError

expectTableOrPermanentViewNotTempViewError

expectPersistentFuncError

permanentViewNotSupportedByStreamingReadingAPIError

starNotAllowedWhenGroupByOrdinalPositionUsedError

invalidStarUsageError

singleTableStarInCountNotAllowedError

orderByPositionRangeError

groupByPositionRefersToAggregateFunctionError

groupByPositionRangeError

generatorNotExpectedError

functionWithUnsupportedSyntaxError

nonDeterministicFilterInAggregateError

nonBooleanFilterInAggregateError

aggregateInAggregateFilterError

windowFunctionInAggregateFilterError

aliasNumberNotMatchColumnNumberError

aliasesNumberNotMatchUDTFOutputError

windowAggregateFunctionWithFilterNotSupportedError

windowFunctionInsideAggregateFunctionNotAllowedError

expressionWithoutWindowExpressionError

expressionWithMultiWindowExpressionsError

windowFunctionNotAllowedError

cannotSpecifyWindowFrameError