mirror of
https://github.com/minio/minio.git
synced 2024-12-25 22:55:54 -05:00
643 lines
17 KiB
Go
643 lines
17 KiB
Go
// +build ignore
|
|
|
|
/*
|
|
* Minio Cloud Storage, (C) 2019 Minio, Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package s3select
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Validation errors.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////
|
|
func errExpressionTooLong(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ExpressionTooLong",
|
|
message: "The SQL expression is too long: The maximum byte-length for the SQL expression is 256 KB.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errColumnTooLong(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ColumnTooLong",
|
|
message: "The length of a column in the result is greater than maxCharsPerColumn of 1 MB.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errOverMaxColumn(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "OverMaxColumn",
|
|
message: "The number of columns in the result is greater than the maximum allowable number of columns.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errOverMaxRecordSize(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "OverMaxRecordSize",
|
|
message: "The length of a record in the input or result is greater than maxCharsPerRecord of 1 MB.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errInvalidColumnIndex(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "InvalidColumnIndex",
|
|
message: "Column index in the SQL expression is invalid.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errInvalidTextEncoding(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "InvalidTextEncoding",
|
|
message: "Invalid encoding type. Only UTF-8 encoding is supported.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errInvalidTableAlias(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "InvalidTableAlias",
|
|
message: "The SQL expression contains an invalid table alias.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errUnsupportedSyntax(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "UnsupportedSyntax",
|
|
message: "Encountered invalid syntax.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errAmbiguousFieldName(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "AmbiguousFieldName",
|
|
message: "Field name matches to multiple fields in the file. Check the SQL expression and the file, and try again.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errIntegerOverflow(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "IntegerOverflow",
|
|
message: "Integer overflow or underflow in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errIllegalSQLFunctionArgument(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "IllegalSqlFunctionArgument",
|
|
message: "Illegal argument was used in the SQL function.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errMultipleDataSourcesUnsupported(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "MultipleDataSourcesUnsupported",
|
|
message: "Multiple data sources are not supported.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errMissingHeaders(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "MissingHeaders",
|
|
message: "Some headers in the query are missing from the file. Check the file and try again.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errUnrecognizedFormatException(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "UnrecognizedFormatException",
|
|
message: "Encountered an invalid record type.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// SQL parsing errors.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
func errLexerInvalidChar(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "LexerInvalidChar",
|
|
message: "The SQL expression contains an invalid character.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errLexerInvalidOperator(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "LexerInvalidOperator",
|
|
message: "The SQL expression contains an invalid literal.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errLexerInvalidLiteral(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "LexerInvalidLiteral",
|
|
message: "The SQL expression contains an invalid operator.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errLexerInvalidIONLiteral(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "LexerInvalidIONLiteral",
|
|
message: "The SQL expression contains an invalid operator.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedDatePart(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedDatePart",
|
|
message: "Did not find the expected date part in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedKeyword(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedKeyword",
|
|
message: "Did not find the expected keyword in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedTokenType(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedTokenType",
|
|
message: "Did not find the expected token in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpected2TokenTypes(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpected2TokenTypes",
|
|
message: "Did not find the expected token in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedNumber(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedNumber",
|
|
message: "Did not find the expected number in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedRightParenBuiltinFunctionCall(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedRightParenBuiltinFunctionCall",
|
|
message: "Did not find the expected right parenthesis character in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedTypeName(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedTypeName",
|
|
message: "Did not find the expected type name in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedWhenClause(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedWhenClause",
|
|
message: "Did not find the expected WHEN clause in the SQL expression. CASE is not supported.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnsupportedToken(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnsupportedToken",
|
|
message: "The SQL expression contains an unsupported token.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnsupportedLiteralsGroupBy(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnsupportedLiteralsGroupBy",
|
|
message: "The SQL expression contains an unsupported use of GROUP BY.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedMember(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedMember",
|
|
message: "The SQL expression contains an unsupported use of MEMBER.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnsupportedCase(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnsupportedCase",
|
|
message: "The SQL expression contains an unsupported use of CASE.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnsupportedCaseClause(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnsupportedCaseClause",
|
|
message: "The SQL expression contains an unsupported use of CASE.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnsupportedAlias(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnsupportedAlias",
|
|
message: "The SQL expression contains an unsupported use of ALIAS.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseInvalidPathComponent(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseInvalidPathComponent",
|
|
message: "The SQL expression contains an invalid path component.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseMissingIdentAfterAt(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseMissingIdentAfterAt",
|
|
message: "Did not find the expected identifier after the @ symbol in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnexpectedOperator(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnexpectedOperator",
|
|
message: "The SQL expression contains an unexpected operator.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnexpectedTerm(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnexpectedTerm",
|
|
message: "The SQL expression contains an unexpected term.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnexpectedToken(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnexpectedToken",
|
|
message: "The SQL expression contains an unexpected token.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnExpectedKeyword(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnExpectedKeyword",
|
|
message: "The SQL expression contains an unexpected keyword.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedExpression(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedExpression",
|
|
message: "Did not find the expected SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedLeftParenAfterCast(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedLeftParenAfterCast",
|
|
message: "Did not find the expected left parenthesis after CAST in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedLeftParenValueConstructor(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedLeftParenValueConstructor",
|
|
message: "Did not find expected the left parenthesis in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedLeftParenBuiltinFunctionCall(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedLeftParenBuiltinFunctionCall",
|
|
message: "Did not find the expected left parenthesis in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedArgumentDelimiter(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedArgumentDelimiter",
|
|
message: "Did not find the expected argument delimiter in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseCastArity(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseCastArity",
|
|
message: "The SQL expression CAST has incorrect arity.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseEmptySelect(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseEmptySelect",
|
|
message: "The SQL expression contains an empty SELECT.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseSelectMissingFrom(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseSelectMissingFrom",
|
|
message: "The SQL expression contains a missing FROM after SELECT list.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedIdentForGroupName(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedIdentForGroupName",
|
|
message: "GROUP is not supported in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedIdentForAlias(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedIdentForAlias",
|
|
message: "Did not find the expected identifier for the alias in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseUnsupportedCallWithStar(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseUnsupportedCallWithStar",
|
|
message: "Only COUNT with (*) as a parameter is supported in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseMalformedJoin(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseMalformedJoin",
|
|
message: "JOIN is not supported in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseExpectedIdentForAt(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseExpectedIdentForAt",
|
|
message: "Did not find the expected identifier for AT name in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errParseCannotMixSqbAndWildcardInSelectList(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "ParseCannotMixSqbAndWildcardInSelectList",
|
|
message: "Cannot mix [] and * in the same expression in a SELECT list in SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CAST() related errors.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
func errCastFailed(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "CastFailed",
|
|
message: "Attempt to convert from one data type to another using CAST failed in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errInvalidCast(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "InvalidCast",
|
|
message: "Attempt to convert from one data type to another using CAST failed in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEvaluatorInvalidTimestampFormatPattern(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EvaluatorInvalidTimestampFormatPattern",
|
|
message: "Invalid time stamp format string in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEvaluatorInvalidTimestampFormatPatternAdditionalFieldsRequired(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EvaluatorInvalidTimestampFormatPattern",
|
|
message: "Time stamp format pattern requires additional fields in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEvaluatorInvalidTimestampFormatPatternSymbolForParsing(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EvaluatorInvalidTimestampFormatPatternSymbolForParsing",
|
|
message: "Time stamp format pattern contains a valid format symbol that cannot be applied to time stamp parsing in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEvaluatorTimestampFormatPatternDuplicateFields(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EvaluatorTimestampFormatPatternDuplicateFields",
|
|
message: "Time stamp format pattern contains multiple format specifiers representing the time stamp field in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEvaluatorTimestampFormatPatternHourClockAmPmMismatch(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EvaluatorTimestampFormatPatternHourClockAmPmMismatch",
|
|
message: "Time stamp format pattern contains a 12-hour hour of day format symbol but doesn't also contain an AM/PM field, or it contains a 24-hour hour of day format specifier and contains an AM/PM field in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEvaluatorUnterminatedTimestampFormatPatternToken(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EvaluatorUnterminatedTimestampFormatPatternToken",
|
|
message: "Time stamp format pattern contains unterminated token in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEvaluatorInvalidTimestampFormatPatternToken(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EvaluatorInvalidTimestampFormatPatternToken",
|
|
message: "Time stamp format pattern contains an invalid token in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEvaluatorInvalidTimestampFormatPatternSymbol(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EvaluatorInvalidTimestampFormatPatternSymbol",
|
|
message: "Time stamp format pattern contains an invalid symbol in the SQL expression.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Generic S3 HTTP handler errors.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
func errBusy(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "Busy",
|
|
message: "The service is unavailable. Please retry.",
|
|
statusCode: 503,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errUnauthorizedAccess(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "UnauthorizedAccess",
|
|
message: "You are not authorized to perform this operation",
|
|
statusCode: 401,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errEmptyRequestBody(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "EmptyRequestBody",
|
|
message: "Request body cannot be empty.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errUnsupportedRangeHeader(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "UnsupportedRangeHeader",
|
|
message: "Range header is not supported for this operation.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|
|
|
|
func errUnsupportedStorageClass(err error) *s3Error {
|
|
return &s3Error{
|
|
code: "UnsupportedStorageClass",
|
|
message: "Encountered an invalid storage class. Only STANDARD, STANDARD_IA, and ONEZONE_IA storage classes are supported.",
|
|
statusCode: 400,
|
|
cause: err,
|
|
}
|
|
}
|