Refactor s3select to support parquet. (#7023)

Also handle pretty formatted JSON documents.

pkg/s3select/unused-errors.go

@@ -0,0 +1,642 @@
+// +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,
+	}
+}