blob: 0460edf3af646534abc92c721d38acfacfc569bb [file] [log] [blame]
// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package syncql
error (
BadFieldInWhere(off int64) {
"en": "[{off}]Where field must be 'k' or 'v[{.<ident>}...]'.",
}
BoolInvalidExpression(off int64) {
"en": "[{off}]Boolean operands may only be used in equals and not equals expressions.",
}
CheckOfUnknownStatementType(off int64) {
"en": "[{off}]Cannot semantically check unknown statement type.",
}
CouldNotConvert(off int64, from string, to string) {
"en": "[{off}]Could not convert {from} to {to}.",
}
DotNotationDisallowedForKey(off int64) {
"en": "[{off}]Dot notation may not be used on a key field.",
}
ErrorCompilingRegularExpression(off int64, regex string, err error) {
"en": "[{off}]The following error encountered compiling regex '{regex}': {err}",
}
ExecOfUnknownStatementType(off int64, statementType string) {
"en": "[{off}]Cannot execute unknown statement type: {statementType}.",
}
Expected(off int64, expected string) {
"en": "[{off}]Expected '{expected}'.",
}
ExpectedFrom(off int64, found string) {
"en": "[{off}]Expected 'from', found {found}.",
}
ExpectedIdentifier(off int64, found string) {
"en": "[{off}]Expected identifier, found {found}.",
}
ExpectedOperand(off int64, found string) {
"en": "[{off}]Expected operand, found {found}.",
}
ExpectedOperator(off int64, found string) {
"en": "[{off}]Expected operator, found {found}.",
}
FunctionArgCount(off int64, name string, expected int64, found int64) {
"en": "[{off}]Function '{name}' expects {expected} args, found: {found}.",
}
FunctionAtLeastArgCount(off int64, name string, expected int64, found int64) {
"en": "[{off}]Function '{name}' expects at least {expected} args, found: {found}.",
}
FunctionTypeInvalidArg(off int64) {
"en": "[{off}]Function 'Type()' cannot get type of argument -- expecting object.",
}
FunctionLenInvalidArg(off int64) {
"en": "[{off}]Function 'Len()' expects array, list, set, map, string or nil.",
}
FunctionArgBad(off int64, funcName, argName string) {
"en": "[{off}]Function '{funcName}' arg '{argName}' could not be resolved.",
}
FunctionNotFound(off int64, name string) {
"en": "[{off}]Function '{name}' not found.",
}
ArgMustBeField(off int64) {
"en": "[{off}]Argument must be a value field (i.e., must begin with 'v').",
}
BigIntConversionError(off int64, err error) {
"en": "[{off}]Can't convert to BigInt: {err}.",
}
BigRatConversionError(off int64, err error) {
"en": "[{off}]Can't convert to BigRat: {err}.",
}
BoolConversionError(off int64, err error) {
"en": "[{off}]Can't convert to Bool: {err}.",
}
ComplexConversionError(off int64, err error) {
"en": "[{off}]Can't convert to Complex: {err}.",
}
UintConversionError(off int64, err error) {
"en": "[{off}]Can't convert to Uint: {err}.",
}
TimeConversionError(off int64, err error) {
"en": "[{off}]Can't convert to time: {err}.",
}
LocationConversionError(off int64, err error) {
"en": "[{off}]Can't convert to location: {err}.",
}
StringConversionError(off int64, err error) {
"en": "[{off}]Can't convert to string: {err}.",
}
FloatConversionError(off int64, err error) {
"en": "[{off}]Can't convert to float: {err}.",
}
IntConversionError(off int64, err error) {
"en": "[{off}]Can't convert to int: {err}.",
}
IsIsNotRequireLhsValue(off int64) {
"en": "[{off}]'Is/is not' expressions require left operand to be a value operand.",
}
IsIsNotRequireRhsNil(off int64) {
"en": "[{off}]'Is/is not' expressions require right operand to be nil.",
}
InvalidEscapeSequence(off int64) {
"en": "[{off}Expected percent, or underscore after escape character.]",
}
InvalidSelectField(off int64) {
"en": "[{off}]Select field must be 'k' or 'v[{.<ident>}...]'.",
}
KeyExpressionLiteral(off int64) {
"en": "[{off}]Key (i.e., 'k') compares against literals must be string literal.",
}
KeyValueStreamError(off int64, err error) {
"en": "[{off}]KeyValueStream error: {err}.",
}
LikeExpressionsRequireRhsString(off int64) {
"en": "[{off}]Like expressions require right operand of type <string-literal>.",
}
LimitMustBeGt0(off int64) {
"en": "[{off}]Limit must be > 0.",
}
MaxStatementLenExceeded(off, max, found int64) {
"en": "[{off}]Maximum length of statements is {max}; found {found}.",
}
NoStatementFound(off int64) {
"en": "[{off}]No statement found.",
}
OffsetMustBeGe0(off int64) {
"en": "[{off}]Offset must be > 0.",
}
ScanError(off int64, err error) {
"en": "[{off}]Scan error: {err}.",
}
TableCantAccess(off int64, table string, err error) {
"en": "[{off}]Table {table} does not exist (or cannot be accessed): {err}.",
}
Unexpected(off int64, found string) {
"en": "[{off}]Unexpected: {found}.",
}
UnexpectedEndOfStatement(off int64) {
"en": "[{off}]Unexpected end of statement.",
}
UnknownIdentifier(off int64, found string) {
"en": "[{off}]Unknown identifier: {found}.",
}
InvalidEscapeChar(off int64) {
"en": "[{off}]Invalid escape character cannot be space or backslash.",
}
DidYouMeanLowercaseK(off int64) {
"en": "[{off}]Did you mean: 'k'?",
}
DidYouMeanLowercaseV(off int64) {
"en": "[{off}]Did you mean: 'v'?",
}
DidYouMeanFunction(off int64, correctName string) {
"en": "[{off}]Did you mean: '{correctName}'?",
}
NotEnoughParamValuesSpecified(off int64) {
"en": "[{off}]Not enough parameter values specified.",
}
TooManyParamValuesSpecified(off int64) {
"en": "[{off}]Too many parameter values specified.",
}
PreparedStatementNotFound() {
"en": "[0]Prepared statement not found.",
}
IndexKindNotSupported(off int64, kind string, fieldName string, table string) {
"en": "[{off}]Index kind {kind} of field {fieldName} on table {table} not supported.",
}
InvalidIndexField(off int64, fieldName string, table string) {
"en": "[{off}]Invalid index field {fieldName} returned by table {table}.",
}
NotWritable(table string) {
"en": "[0]Can't write to table {table} (not supported on batch/connection).",
}
OperationNotSupported(operation string) {
"en": "[0]{operation} not supported.",
}
)