query

Documentation

Index

• Constants
• Variables
• func Abs(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Acos(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func AddDay(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func AddFlagElement(ctx context.Context, filter *Filter, expr parser.AddFlagElement) error
• func AddHour(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func AddMicro(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func AddMilli(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func AddMinute(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func AddMonth(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func AddNano(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func AddSecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func AddYear(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func All(rowValue value.RowValue, list []value.RowValue, operator string, ...) (ternary.Value, error)
• func Analyze(ctx context.Context, view *View, fn parser.AnalyticFunction, ...) error
• func Any(rowValue value.RowValue, list []value.RowValue, operator string, ...) (ternary.Value, error)
• func Asin(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Atan(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Atan2(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Avg(list []value.Primary, _ *cmd.Flags) value.Primary
• func Base64Decode(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Base64Encode(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Bin(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func BinToDec(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Boolean(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func ByteLen(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func CalcMinimumRequired(i1 int, i2 int, defaultMinimumRequired int) int
• func Calculate(p1 value.Primary, p2 value.Primary, operator int) value.Primary
• func Call(ctx context.Context, fn parser.Function, args []value.Primary) (value.Primary, error)
• func Ceil(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Chdir(ctx context.Context, filter *Filter, expr parser.Chdir) error
• func CheckArgsLen(expr parser.AnalyticFunction, length []int) error
• func Coalesce(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func ContextForPreparedStatement(ctx context.Context, values *ReplaceValues) context.Context
• func ContextForStoringResults(ctx context.Context) context.Context
• func ConvertFieldContents(val value.Primary, forTextTable bool) (string, string, text.FieldAlignment)
• func ConvertFileHandlerError(err error, ident parser.Identifier) error
• func ConvertLoadConfigurationError(err error) error
• func Cos(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Count(list []value.Primary, _ *cmd.Flags) value.Primary
• func CreateFilePath(filename parser.Identifier, repository string) (string, error)
• func CrossJoin(ctx context.Context, filter *Filter, view *View, joinView *View) error
• func DateDiff(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Datetime(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func DatetimeFormat(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Day(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func DayOfYear(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func DeclareView(ctx context.Context, filter *Filter, expr parser.ViewDeclaration) error
• func Distinguish(list []value.Primary, flags *cmd.Flags) []value.Primary
• func Echo(ctx context.Context, filter *Filter, expr parser.Echo) (string, error)
• func EncodeView(ctx context.Context, fp io.Writer, view *View, fileInfo *FileInfo, ...) (string, error)
• func Enotation(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func EnotationToDec(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Exp(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Exp2(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Expm1(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func FetchCursor(ctx context.Context, filter *Filter, name parser.Identifier, ...) (bool, error)
• func Float(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Floor(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Format(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func FormatCount(i int, obj string) string
• func GetRuntimeInformation(tx *Transaction, expr parser.RuntimeInformation) (value.Primary, error)
• func Hex(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func HexDecode(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func HexEncode(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func HexToDec(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func HistoryFilePath(filename string) (string, error)
• func Hour(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func If(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Ifnull(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func InIntSlice(i int, list []int) bool
• func InRowValueList(rowValue value.RowValue, list []value.RowValue, matchType int, operator string, ...) (ternary.Value, error)
• func InStrSliceWithCaseInsensitive(s string, list []string) bool
• func InnerJoin(ctx context.Context, parentFilter *Filter, view *View, joinView *View, ...) error
• func Instr(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Integer(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Is(p1 value.Primary, p2 value.Primary) ternary.Value
• func JsonAgg(list []value.Primary) value.Primary
• func JsonObject(ctx context.Context, filter *Filter, fn parser.Function) (value.Primary, error)
• func JsonValue(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Len(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Like(p1 value.Primary, p2 value.Primary) ternary.Value
• func ListAgg(list []value.Primary, separator string) value.Primary
• func ListElem(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func LoadContentsFromFile(ctx context.Context, tx *Transaction, fpath parser.Identifier) (content string, err error)
• func LoadStatementsFromFile(ctx context.Context, tx *Transaction, fpath parser.Identifier) (statements []parser.Statement, err error)
• func Log10(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Log1p(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Log2(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Lower(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Lpad(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Ltrim(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func MathLog(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Max(list []value.Primary, flags *cmd.Flags) value.Primary
• func Md5(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Md5Hmac(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Median(list []value.Primary, flags *cmd.Flags) value.Primary
• func Microsecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Millisecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Min(list []value.Primary, flags *cmd.Flags) value.Primary
• func Minute(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Month(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Nanosecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func NewAddFlagNotSupportedNameError(expr parser.AddFlagElement) error
• func NewBuiltInFunctionDeclaredError(expr parser.Identifier) error
• func NewCombinedSetFieldLengthError(selectEntity parser.QueryExpression, fieldLen int) error
• func NewCommitError(expr parser.Expression, message string) error
• func NewContextIsDone(message string) error
• func NewCursorClosedError(cursor parser.Identifier) error
• func NewCursorFetchLengthError(cursor parser.Identifier, returnLen int) error
• func NewCursorOpenError(cursor parser.Identifier) error
• func NewCursorRedeclaredError(cursor parser.Identifier) error
• func NewDataParsingError(file parser.QueryExpression, filepath string, message string) error
• func NewDeleteTableNotSpecifiedError(query parser.DeleteQuery) error
• func NewDuplicateFieldNameError(fieldName parser.Identifier) error
• func NewDuplicateParameterError(expr parser.Variable) error
• func NewDuplicateStatementNameError(name parser.Identifier) error
• func NewDuplicateTableNameError(table parser.Identifier) error
• func NewEmptyJsonQueryError(expr parser.JsonQuery) error
• func NewEmptyJsonTableError(expr parser.JsonQuery) error
• func NewExternalCommandError(expr parser.Expression, message string) error
• func NewFieldAmbiguousError(field parser.QueryExpression) error
• func NewFieldLengthNotMatchError() error
• func NewFieldNotExistError(field parser.QueryExpression) error
• func NewFieldNotGroupKeyError(field parser.QueryExpression) error
• func NewFileAlreadyExistError(file parser.Identifier) error
• func NewFileLockTimeoutError(file parser.Identifier) error
• func NewFileNameAmbiguousError(file parser.Identifier) error
• func NewFileNotExistError(file parser.QueryExpression) error
• func NewFileUnableToReadError(file parser.Identifier) error
• func NewFlagValueNotAllowedFormatError(setFlag parser.SetFlag) error
• func NewForcedExit(code int) error
• func NewFormatStringLengthNotMatchError() error
• func NewFormatUnexpectedTerminationError() error
• func NewFunctionArgumentLengthError(expr parser.QueryExpression, funcname string, argslen []int) error
• func NewFunctionArgumentLengthErrorWithCustomArgs(expr parser.QueryExpression, funcname string, argstr string) error
• func NewFunctionInvalidArgumentError(function parser.QueryExpression, funcname string, message string) error
• func NewFunctionNotExistError(expr parser.QueryExpression, funcname string) error
• func NewFunctionRedeclaredError(expr parser.Identifier) error
• func NewIOError(expr parser.Expression, message string) error
• func NewInLineTableRedefinedError(table parser.Identifier) error
• func NewIncorrectCommandUsageError(message string) error
• func NewInlineTableFieldLengthError(query parser.SelectQuery, table parser.Identifier, fieldLen int) error
• func NewInsertRowValueLengthError(rowValue parser.RowValue, valueLen int) error
• func NewInsertSelectFieldLengthError(query parser.SelectQuery, fieldLen int) error
• func NewInternalRecordIdEmptyError() error
• func NewInternalRecordIdNotExistError() error
• func NewInvalidCursorStatementError(statement parser.Identifier) error
• func NewInvalidEventNameError(expr parser.Identifier) error
• func NewInvalidFetchPositionError(position parser.FetchPosition) error
• func NewInvalidFlagNameError(expr parser.Expression, name string) error
• func NewInvalidFlagValueError(expr parser.SetFlag, message string) error
• func NewInvalidFlagValueToBeRemovedError(unsetFlag parser.RemoveFlagElement) error
• func NewInvalidLimitNumberError(clause parser.LimitClause) error
• func NewInvalidLimitPercentageError(clause parser.LimitClause) error
• func NewInvalidOffsetNumberError(clause parser.OffsetClause) error
• func NewInvalidPathError(expr parser.Expression, path string, message string) error
• func NewInvalidReloadTypeError(expr parser.Reload, name string) error
• func NewInvalidRuntimeInformationError(expr parser.RuntimeInformation) error
• func NewInvalidTableAttributeNameError(expr parser.Identifier) error
• func NewInvalidTableAttributeValueError(expr parser.SetTableAttribute, message string) error
• func NewInvalidTableObjectError(expr parser.TableObject, objectName string) error
• func NewInvalidValueExpressionError(expr parser.QueryExpression) error
• func NewJsonQueryTooManyRecordsError(expr parser.JsonQuery) error
• func NewLoadConfigurationError(expr parser.Expression, message string) error
• func NewLoadJsonError(expr parser.JsonQuery, message string) error
• func NewNestedAggregateFunctionsError(expr parser.QueryExpression) error
• func NewNotGroupingRecordsError(expr parser.QueryExpression, funcname string) error
• func NewNotTableError(expr parser.QueryExpression) error
• func NewPreparedStatementSyntaxError(err *parser.SyntaxError) error
• func NewPromptEvaluationError(message string) error
• func NewPseudoCursorError(cursor parser.Identifier) error
• func NewRemoveFlagNotSupportedNameError(expr parser.RemoveFlagElement) error
• func NewReplaceValueLengthError(expr parser.Expression, message string) error
• func NewRollbackError(expr parser.Expression, message string) error
• func NewRowValueLengthInComparisonError(expr parser.QueryExpression, valueLen int) error
• func NewRowValueLengthInListError(i int) error
• func NewSelectFieldLengthInComparisonError(query parser.Subquery, valueLen int) error
• func NewShowInvalidObjectTypeError(expr parser.Expression, objectType string) error
• func NewSourceInvalidFilePathError(source parser.Source, arg parser.QueryExpression) error
• func NewStatementNotExistError(name parser.Identifier) error
• func NewStatementReplaceValueNotSpecifiedError(placeholder parser.Placeholder) error
• func NewStdinEmptyError(stdin parser.Stdin) error
• func NewSubqueryTooManyFieldsError(expr parser.Subquery) error
• func NewSubqueryTooManyRecordsError(expr parser.Subquery) error
• func NewSyntaxError(err *parser.SyntaxError) error
• func NewSystemError(message string) error
• func NewTableAttributeUnchangedError(fpath string) error
• func NewTableAttributeValueNotAllowedFormatError(expr parser.SetTableAttribute) error
• func NewTableFieldLengthError(query parser.SelectQuery, table parser.Identifier, fieldLen int) error
• func NewTableNotLoadedError(table parser.Identifier) error
• func NewTableObjectArgumentsLengthError(expr parser.TableObject, argLen int) error
• func NewTableObjectInvalidArgumentError(expr parser.TableObject, message string) error
• func NewTableObjectInvalidDelimiterError(expr parser.TableObject, delimiter string) error
• func NewTableObjectInvalidDelimiterPositionsError(expr parser.TableObject, positions string) error
• func NewTableObjectInvalidJsonQueryError(expr parser.TableObject, jsonQuery string) error
• func NewTableObjectJsonArgumentsLengthError(expr parser.TableObject, argLen int) error
• func NewTemporaryTableFieldLengthError(query parser.SelectQuery, table parser.Identifier, fieldLen int) error
• func NewTemporaryTableRedeclaredError(table parser.Identifier) error
• func NewUndeclaredCursorError(cursor parser.Identifier) error
• func NewUndeclaredTemporaryTableError(table parser.Identifier) error
• func NewUndeclaredVariableError(expr parser.Variable) error
• func NewUndefinedInLineTableError(table parser.Identifier) error
• func NewUnknownFormatPlaceholderError(placeholder rune) error
• func NewUnpermittedFunctionStatementError(expr parser.QueryExpression, funcname string) error
• func NewUpdateFieldNotExistError(field parser.QueryExpression) error
• func NewUpdateValueAmbiguousError(field parser.QueryExpression, value parser.QueryExpression) error
• func NewUserTriggeredError(expr parser.Trigger, message string) error
• func NewVariableRedeclaredError(expr parser.Variable) error
• func Now(filter *Filter, fn parser.Function, args []value.Primary) (value.Primary, error)
• func Nullif(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func NumberFormat(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Oct(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func OctToDec(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func OuterJoin(ctx context.Context, parentFilter *Filter, view *View, joinView *View, ...) error
• func ParseExecuteStatements(ctx context.Context, filter *Filter, expr parser.Execute) ([]parser.Statement, error)
• func ParseJoinCondition(join parser.Join, view *View, joinView *View) (parser.QueryExpression, []parser.FieldReference, []parser.FieldReference, ...)
• func Pow(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Print(ctx context.Context, filter *Filter, expr parser.Print) (string, error)
• func Printf(ctx context.Context, filter *Filter, expr parser.Printf) (string, error)
• func Pwd(expr parser.Pwd) (string, error)
• func Rand(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Reload(ctx context.Context, tx *Transaction, expr parser.Reload) error
• func RemoveFlagElement(ctx context.Context, filter *Filter, expr parser.RemoveFlagElement) error
• func Replace(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Round(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Rpad(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Rtrim(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func SearchCSVFilePath(filename parser.Identifier, repository string) (string, error)
• func SearchFilePath(filename parser.Identifier, repository string, format cmd.Format, ...) (string, cmd.Format, error)
• func SearchFilePathFromAllTypes(filename parser.Identifier, repository string) (string, error)
• func SearchFilePathWithExtType(filename parser.Identifier, repository string, extTypes []string) (string, error)
• func SearchFixedLengthFilePath(filename parser.Identifier, repository string) (string, error)
• func SearchJsonFilePath(filename parser.Identifier, repository string) (string, error)
• func SearchLTSVFilePath(filename parser.Identifier, repository string) (string, error)
• func Second(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func SerializeComparisonKeys(buf *bytes.Buffer, values []value.Primary, flags *cmd.Flags)
• func SerializeKey(buf *bytes.Buffer, val value.Primary, flags *cmd.Flags)
• func SetEnvVar(ctx context.Context, filter *Filter, expr parser.SetEnvVar) error
• func SetFlag(ctx context.Context, filter *Filter, expr parser.SetFlag) error
• func Sha1(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Sha1Hmac(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Sha256(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Sha256Hmac(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Sha512(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Sha512Hmac(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func ShowFields(ctx context.Context, filter *Filter, expr parser.ShowFields) (string, error)
• func ShowFlag(flags *cmd.Flags, expr parser.ShowFlag) (string, error)
• func ShowObjects(filter *Filter, expr parser.ShowObjects) (string, error)
• func Sin(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Source(ctx context.Context, filter *Filter, expr parser.Source) ([]parser.Statement, error)
• func Sqrt(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func String(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Substr(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Sum(list []value.Primary, _ *cmd.Flags) value.Primary
• func Syntax(ctx context.Context, filter *Filter, expr parser.Syntax) string
• func Tan(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func Ternary(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func TimeDiff(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func TimeNanoDiff(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Trim(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func TruncDay(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func TruncMicro(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func TruncMilli(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func TruncMinute(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func TruncMonth(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func TruncNano(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func TruncSecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func TruncTime(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func UTC(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func UnixNanoTime(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func UnixTime(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func UnsetEnvVar(expr parser.UnsetEnvVar) error
• func Upper(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)
• func WeekOfYear(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Weekday(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Width(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• func Year(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)
• type AddFlagNotSupportedNameError
• type AggregateFunction
• type AliasMap
  • func (m AliasMap) Add(alias parser.Identifier, path string) error
  • func (m AliasMap) Get(alias parser.Identifier) (string, error)
• type AliasNodes
  • func (list AliasNodes) Add(alias parser.Identifier, path string) error
  • func (list AliasNodes) Get(alias parser.Identifier) (path string, err error)
• type AnalyticFunction
• type AnalyticJsonAgg
  • func (fn AnalyticJsonAgg) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn AnalyticJsonAgg) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type AnalyticListAgg
  • func (fn AnalyticListAgg) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn AnalyticListAgg) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type BaseError
  • func NewBaseError(expr parser.Expression, message string, code int, number int) *BaseError
  • func NewBaseErrorWithPrefix(prefix string, message string, code int, number int) *BaseError
  • func (e *BaseError) Char() int
  • func (e *BaseError) Code() int
  • func (e *BaseError) Error() string
  • func (e *BaseError) Line() int
  • func (e *BaseError) Message() string
  • func (e *BaseError) Number() int
  • func (e *BaseError) Source() string
• type BuiltInFunctionDeclaredError
• type Cell
  • func NewCell(val value.Primary) Cell
  • func NewGroupCell(values []value.Primary) Cell
  • func (cell Cell) GroupedValue(index int) value.Primary
  • func (cell Cell) Len() int
  • func (cell Cell) Value() value.Primary
• type CombinedSetFieldLengthError
• type CommitError
• type Completer
  • func NewCompleter(filter *Filter) *Completer
  • func (c *Completer) AddFlagArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) AllColumnList() []string
  • func (c *Completer) AlterArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) BracketIsEnclosed() bool
  • func (c *Completer) CaseExpression(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) ColumnList(tableName string, repository string) []string
  • func (c *Completer) CreateArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) CursorStatus(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) DeclareArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) DeleteArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) DisposeArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) Do(line []rune, pos int, index int) (readline.CandidateList, int)
  • func (c *Completer) EncloseQuotation(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) FetchArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) FunctionArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) GetStatementPrefix(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) InsertArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) ListFiles(path string, includeExt []string, repository string) []string
  • func (c *Completer) PrepareArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) RemoveFlagArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SearchAllTables(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SearchAllTablesWithSpace(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SearchDirs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SearchExecutableFiles(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SearchValues(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SearchValuesWithSpace(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SelectArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SetArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) SetLastIndex(line string)
  • func (c *Completer) ShowArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) Statements(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) TableObjectArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) Update()
  • func (c *Completer) UpdateArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) UpdateTokens(line string, origLine string)
  • func (c *Completer) UsingArgs(line string, origLine string, index int) readline.CandidateList
  • func (c *Completer) WithArgs(line string, origLine string, index int) readline.CandidateList
• type ContainsSubstitusion
  • func (c *ContainsSubstitusion) Error() string
• type ContextIsDone
• type CumeDist
  • func (fn CumeDist) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn CumeDist) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type Cursor
  • func NewCursor(e parser.CursorDeclaration) *Cursor
  • func NewPseudoCursor(tx *Transaction, values []value.Primary) *Cursor
  • func (c *Cursor) Close(name parser.Identifier) error
  • func (c *Cursor) Count() (int, error)
  • func (c *Cursor) Fetch(name parser.Identifier, position int, number int) ([]value.Primary, error)
  • func (c *Cursor) IsInRange() (ternary.Value, error)
  • func (c *Cursor) IsOpen() ternary.Value
  • func (c *Cursor) Open(ctx context.Context, filter *Filter, name parser.Identifier, ...) error
  • func (c *Cursor) Pointer() (int, error)
• type CursorClosedError
• type CursorFetchLengthError
• type CursorMap
  • func (m CursorMap) AddPseudoCursor(tx *Transaction, name parser.Identifier, values []value.Primary) error
  • func (m CursorMap) Close(name parser.Identifier) error
  • func (m CursorMap) Count(name parser.Identifier) (int, error)
  • func (m CursorMap) Declare(expr parser.CursorDeclaration) error
  • func (m CursorMap) Dispose(name parser.Identifier) error
  • func (m CursorMap) Fetch(name parser.Identifier, position int, number int) ([]value.Primary, error)
  • func (m CursorMap) IsInRange(name parser.Identifier) (ternary.Value, error)
  • func (m CursorMap) IsOpen(name parser.Identifier) (ternary.Value, error)
  • func (m CursorMap) Keys() []string
  • func (m CursorMap) Open(ctx context.Context, filter *Filter, name parser.Identifier, ...) error
  • func (m CursorMap) SortedKeys() []string
• type CursorOpenError
• type CursorRedeclaredError
• type CursorScopes
  • func (list CursorScopes) AddPseudoCursor(tx *Transaction, name parser.Identifier, values []value.Primary) error
  • func (list CursorScopes) All() CursorMap
  • func (list CursorScopes) Close(name parser.Identifier) error
  • func (list CursorScopes) Count(name parser.Identifier) (int, error)
  • func (list CursorScopes) Declare(expr parser.CursorDeclaration) error
  • func (list CursorScopes) Dispose(name parser.Identifier) error
  • func (list CursorScopes) Fetch(name parser.Identifier, position int, number int) ([]value.Primary, error)
  • func (list CursorScopes) IsInRange(name parser.Identifier) (ternary.Value, error)
  • func (list CursorScopes) IsOpen(name parser.Identifier) (ternary.Value, error)
  • func (list CursorScopes) Open(ctx context.Context, filter *Filter, name parser.Identifier, ...) error
• type DataParsingError
• type DeleteTableNotSpecifiedError
• type DenseRank
  • func (fn DenseRank) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn DenseRank) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type Direction
• type Discard
  • func NewDiscard() *Discard
  • func (d Discard) Close() error
  • func (d Discard) Write(p []byte) (int, error)
• type DuplicateFieldNameError
• type DuplicateParameterError
• type DuplicateStatementNameError
• type DuplicateTableNameError
• type EmptyJsonQueryError
• type EmptyJsonTableError
• type EmptyResultSetError
  • func NewEmptyResultSetError() *EmptyResultSetError
  • func (e EmptyResultSetError) Error() string
• type Error
• type ExternalCommandError
• type FieldAmbiguousError
• type FieldLengthNotMatchError
• type FieldNotExistError
• type FieldNotGroupKeyError
• type FileAlreadyExistError
• type FileInfo
  • func AddColumns(ctx context.Context, parentFilter *Filter, query parser.AddColumns) (*FileInfo, int, error)
  • func CreateTable(ctx context.Context, parentFilter *Filter, query parser.CreateTable) (*FileInfo, error)
  • func Delete(ctx context.Context, parentFilter *Filter, query parser.DeleteQuery) ([]*FileInfo, []int, error)
  • func DropColumns(ctx context.Context, parentFilter *Filter, query parser.DropColumns) (*FileInfo, int, error)
  • func Insert(ctx context.Context, parentFilter *Filter, query parser.InsertQuery) (*FileInfo, int, error)
  • func NewFileInfo(filename parser.Identifier, repository string, format cmd.Format, ...) (*FileInfo, error)
  • func NewFileInfoForCreate(filename parser.Identifier, repository string, delimiter rune, ...) (*FileInfo, error)
  • func RenameColumn(ctx context.Context, parentFilter *Filter, query parser.RenameColumn) (*FileInfo, error)
  • func SetTableAttribute(ctx context.Context, parentFilter *Filter, query parser.SetTableAttribute) (*FileInfo, string, error)
  • func Update(ctx context.Context, parentFilter *Filter, query parser.UpdateQuery) ([]*FileInfo, []int, error)
  • func (f *FileInfo) SetDelimiter(s string) error
  • func (f *FileInfo) SetDelimiterPositions(s string) error
  • func (f *FileInfo) SetEncloseAll(b bool) error
  • func (f *FileInfo) SetEncoding(s string) error
  • func (f *FileInfo) SetFormat(s string) error
  • func (f *FileInfo) SetJsonEscape(s string) error
  • func (f *FileInfo) SetLineBreak(s string) error
  • func (f *FileInfo) SetNoHeader(b bool) error
  • func (f *FileInfo) SetPrettyPrint(b bool) error
• type FileLockTimeoutError
• type FileNameAmbiguousError
• type FileNotExistError
• type FileUnableToReadError
• type Filter
  • func NewFilter(tx *Transaction) *Filter
  • func NewFilterForRecord(parentFilter *Filter, view *View, recordIndex int) *Filter
  • func NewFilterForSequentialEvaluation(parentFilter *Filter, view *View) *Filter
  • func NewFilterWithScopes(tx *Transaction, variableScopes VariableScopes, ...) *Filter
  • func (f *Filter) CreateChildScope() *Filter
  • func (f *Filter) CreateNode() *Filter
  • func (f *Filter) Evaluate(ctx context.Context, expr parser.QueryExpression) (value.Primary, error)
  • func (f *Filter) EvaluateEmbeddedString(ctx context.Context, embedded string) (string, error)
  • func (f *Filter) EvaluateSequentially(ctx context.Context, fn func(*Filter, int) error) error
  • func (f *Filter) LoadInlineTable(ctx context.Context, clause parser.WithClause) error
  • func (f *Filter) Merge(filter *Filter)
  • func (f *Filter) ResetCurrentScope()
• type FirstValue
  • func (fn FirstValue) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn FirstValue) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type FlagValueNotAllowedFormatError
• type ForcedExit
• type FormatStringLengthNotMatchError
• type FormatUnexpectedTerminationError
• type FunctionArgumentLengthError
• type FunctionInvalidArgumentError
• type FunctionNotExistError
• type FunctionRedeclaredError
• type GoroutineManager
  • func GetGoroutineManager() *GoroutineManager
  • func (m *GoroutineManager) AssignRoutineNumber(recordLen int, minimumRequiredPerCore int, cpuNum int) int
  • func (m *GoroutineManager) Release()
• type GoroutineTaskManager
  • func NewGoroutineTaskManager(recordLen int, minimumRequiredPerCore int, cpuNum int) *GoroutineTaskManager
  • func (m *GoroutineTaskManager) Add()
  • func (m *GoroutineTaskManager) Done()
  • func (m *GoroutineTaskManager) Err() error
  • func (m *GoroutineTaskManager) HasError() bool
  • func (m *GoroutineTaskManager) RecordRange(routineIndex int) (int, int)
  • func (m *GoroutineTaskManager) Run(ctx context.Context, fn func(int) error) error
  • func (m *GoroutineTaskManager) SetError(e error)
  • func (m *GoroutineTaskManager) Wait()
• type Header
  • func AddHeaderField(h Header, column string, alias string) (header Header, index int)
  • func MergeHeader(h1 Header, h2 Header) Header
  • func NewDualHeader() Header
  • func NewEmptyHeader(len int) Header
  • func NewHeader(view string, words []string) Header
  • func NewHeaderWithAutofill(view string, words []string) Header
  • func NewHeaderWithId(view string, words []string) Header
  • func (h Header) Contains(fieldRef parser.FieldReference) (int, error)
  • func (h Header) ContainsInternalId(viewName string) (int, error)
  • func (h Header) ContainsNumber(number parser.ColumnNumber) (int, error)
  • func (h Header) ContainsObject(obj parser.QueryExpression) (int, error)
  • func (h Header) Copy() Header
  • func (h Header) Len() int
  • func (h Header) TableColumnNames() []string
  • func (h Header) TableColumns() []parser.QueryExpression
  • func (h Header) Update(reference string, fields []parser.QueryExpression) error
• type HeaderField
• type IOError
• type InLineTableRedefinedError
• type IncorrectCommandUsageError
• type InlineTableFieldLengthError
• type InlineTableMap
  • func (it InlineTableMap) Get(name parser.Identifier) (*View, error)
  • func (it InlineTableMap) Set(ctx context.Context, parentFilter *Filter, inlineTable parser.InlineTable) error
• type InlineTableNodes
  • func (list InlineTableNodes) Get(name parser.Identifier) (*View, error)
  • func (list InlineTableNodes) Load(ctx context.Context, parentFilter *Filter, clause parser.WithClause) error
  • func (list InlineTableNodes) Set(ctx context.Context, parentFilter *Filter, inlineTable parser.InlineTable) error
• type Input
  • func NewInput(r io.Reader) *Input
  • func (r *Input) Close() error
  • func (r *Input) Read(p []byte) (int, error)
• type InsertRowValueLengthError
• type InsertSelectFieldLengthError
• type InternalRecordIdEmptyError
• type InternalRecordIdNotExistError
• type InvalidCursorStatementError
• type InvalidEventNameError
• type InvalidFetchPositionError
• type InvalidFlagNameError
• type InvalidFlagValueError
• type InvalidFlagValueToBeRemoveError
• type InvalidLimitNumberError
• type InvalidLimitPercentageError
• type InvalidOffsetNumberError
• type InvalidPathError
• type InvalidReloadTypeError
• type InvalidRuntimeInformationError
• type InvalidTableAttributeNameError
• type InvalidTableAttributeValueError
• type InvalidTableObjectError
• type InvalidValueExpressionError
• type JsonQueryTooManyRecordsError
• type Lag
  • func (fn Lag) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn Lag) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type LastValue
  • func (fn LastValue) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn LastValue) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type Lead
  • func (fn Lead) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn Lead) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type LoadConfigurationError
• type LoadJsonError
• type NTile
  • func (fn NTile) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn NTile) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type NestedAggregateFunctionsError
• type NotGroupingRecordsError
• type NotTableError
• type NthValue
  • func (fn NthValue) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn NthValue) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type ObjectStatus
• type ObjectWriter
  • func NewObjectWriter(tx *Transaction) *ObjectWriter
  • func (w *ObjectWriter) BeginBlock()
  • func (w *ObjectWriter) BeginSubBlock()
  • func (w *ObjectWriter) Clear()
  • func (w *ObjectWriter) ClearBlock()
  • func (w *ObjectWriter) EndBlock()
  • func (w *ObjectWriter) EndSubBlock()
  • func (w *ObjectWriter) FitInLine(s string) bool
  • func (w *ObjectWriter) NewLine()
  • func (w *ObjectWriter) String() string
  • func (w *ObjectWriter) Write(s string)
  • func (w *ObjectWriter) WriteColor(s string, effect string)
  • func (w *ObjectWriter) WriteColorWithoutLineBreak(s string, effect string)
  • func (w *ObjectWriter) WriteSpaces(l int)
  • func (w *ObjectWriter) WriteWithAutoLineBreak(s string)
  • func (w *ObjectWriter) WriteWithoutLineBreak(s string)
• type Output
  • func NewOutput() *Output
  • func (w *Output) Close() error
• type PaddingType
• type Partition
  • func (p Partition) Reverse()
• type Partitions
• type PercentRank
  • func (fn PercentRank) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn PercentRank) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type PreparedStatement
  • func NewPreparedStatement(filter *Filter, expr parser.StatementPreparation) (*PreparedStatement, error)
• type PreparedStatementMap
  • func NewPreparedStatementMap() PreparedStatementMap
  • func (m PreparedStatementMap) Delete(name string)
  • func (m PreparedStatementMap) Dispose(expr parser.DisposeStatement) error
  • func (m PreparedStatementMap) Exists(name string) bool
  • func (m PreparedStatementMap) Get(name parser.Identifier) (*PreparedStatement, error)
  • func (m PreparedStatementMap) Load(name string) (*PreparedStatement, bool)
  • func (m PreparedStatementMap) Prepare(filter *Filter, expr parser.StatementPreparation) error
  • func (m PreparedStatementMap) Store(name string, statement *PreparedStatement)
• type PreparedStatementSyntaxError
• type Processor
  • func NewProcessor(tx *Transaction) *Processor
  • func NewProcessorWithFilter(tx *Transaction, filter *Filter) *Processor
  • func (proc *Processor) AutoCommit(ctx context.Context) error
  • func (proc *Processor) AutoRollback() error
  • func (proc *Processor) Case(ctx context.Context, stmt parser.Case) (StatementFlow, error)
  • func (proc *Processor) Commit(ctx context.Context, expr parser.Expression) error
  • func (proc *Processor) ExecExternalCommand(ctx context.Context, stmt parser.ExternalCommand) error
  • func (proc *Processor) Execute(ctx context.Context, statements []parser.Statement) (StatementFlow, error)
  • func (proc *Processor) ExecuteStatement(ctx context.Context, stmt parser.Statement) (StatementFlow, error)
  • func (proc *Processor) IfStmt(ctx context.Context, stmt parser.If) (StatementFlow, error)
  • func (proc *Processor) Log(log string, quiet bool)
  • func (proc *Processor) LogError(log string)
  • func (proc *Processor) LogNotice(log string, quiet bool)
  • func (proc *Processor) LogWarn(log string, quiet bool)
  • func (proc *Processor) NewChildProcessor() *Processor
  • func (proc *Processor) ReleaseResources() error
  • func (proc *Processor) ReleaseResourcesWithErrors() error
  • func (proc *Processor) Rollback(expr parser.Expression) error
  • func (proc *Processor) While(ctx context.Context, stmt parser.While) (StatementFlow, error)
  • func (proc *Processor) WhileInCursor(ctx context.Context, stmt parser.WhileInCursor) (StatementFlow, error)
• type Prompt
  • func NewPrompt(filter *Filter, palette *color.Palette) *Prompt
  • func (p *Prompt) LoadConfig() error
  • func (p *Prompt) Render(ctx context.Context, sequence []PromptElement) (string, error)
  • func (p *Prompt) RenderContinuousPrompt(ctx context.Context) (string, error)
  • func (p *Prompt) RenderPrompt(ctx context.Context) (string, error)
  • func (p *Prompt) StripEscapeSequence(s string) string
• type PromptElement
• type PromptEvaluationError
  • func (e PromptEvaluationError) Error() string
• type PseudoCursorError
• type Rank
  • func (fn Rank) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn Rank) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type ReadLineTerminal
  • func (t ReadLineTerminal) GetSize() (int, int, error)
  • func (t ReadLineTerminal) ReadLine() (string, error)
  • func (t ReadLineTerminal) ReloadConfig() error
  • func (t ReadLineTerminal) SaveHistory(s string) error
  • func (t ReadLineTerminal) SetContinuousPrompt(ctx context.Context)
  • func (t ReadLineTerminal) SetPrompt(ctx context.Context)
  • func (t ReadLineTerminal) Teardown() error
  • func (t ReadLineTerminal) UpdateCompleter()
  • func (t ReadLineTerminal) Write(s string) error
  • func (t ReadLineTerminal) WriteError(s string) error
• type ReadlineListener
  • func (l ReadlineListener) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)
• type Record
  • func NewEmptyRecord(len int) Record
  • func NewRecord(values []value.Primary) Record
  • func NewRecordWithId(internalId int, values []value.Primary) Record
  • func (r Record) Copy() Record
  • func (r Record) GroupLen() int
  • func (r Record) SerializeComparisonKeys(buf *bytes.Buffer, flags *cmd.Flags)
• type RecordReader
• type RecordSet
  • func MergeRecordSetList(list []RecordSet) RecordSet
  • func (r RecordSet) Copy() RecordSet
• type RemoveFlagNotSupportedNameError
• type ReplaceValueLengthError
• type ReplaceValues
  • func NewReplaceValues(replace []parser.ReplaceValue) *ReplaceValues
• type RollbackError
• type RowNumber
  • func (fn RowNumber) CheckArgsLen(expr parser.AnalyticFunction) error
  • func (fn RowNumber) Execute(ctx context.Context, filter *Filter, partition Partition, ...) (map[int]value.Primary, error)
• type RowValueLengthInComparisonError
• type RowValueLengthInListError
• type SelectFieldLengthInComparisonError
• type Session
  • func NewSession() *Session
  • func (sess *Session) CanReadStdin() bool
  • func (sess *Session) Log(log string, quiet bool)
  • func (sess *Session) LogError(log string)
  • func (sess *Session) LogNotice(log string, quiet bool)
  • func (sess *Session) LogWarn(log string, quiet bool)
  • func (sess *Session) WriteToStderr(s string) error
  • func (sess *Session) WriteToStderrWithLineBreak(s string) error
  • func (sess *Session) WriteToStdout(s string) error
  • func (sess *Session) WriteToStdoutWithLineBreak(s string) error
• type ShowInvalidObjectTypeError
• type SortValue
  • func NewSortValue(val value.Primary, flags *cmd.Flags) *SortValue
  • func (v *SortValue) EquivalentTo(compareValue *SortValue) bool
  • func (v *SortValue) Less(compareValue *SortValue) ternary.Value
• type SortValueType
• type SortValues
  • func (values SortValues) EquivalentTo(compareValues SortValues) bool
  • func (values SortValues) Less(compareValues SortValues, directions []int, nullPositions []int) bool
  • func (values SortValues) Serialize(buf *bytes.Buffer)
• type SourceInvalidFilePathError
• type StatementFlow
• type StatementNotExistError
• type StatementReplaceValueNotSpecifiedError
• type StdinEmptyError
• type StringFormatter
  • func NewStringFormatter() *StringFormatter
  • func (f *StringFormatter) Format(format string, values []value.Primary) (string, error)
• type SubqueryTooManyFieldsError
• type SubqueryTooManyRecordsError
• type SyncMap
  • func NewSyncMap() *SyncMap
  • func (m SyncMap) Keys() []string
  • func (m SyncMap) Len() int
  • func (m SyncMap) Range(fn func(key, value interface{}) bool)
  • func (m SyncMap) SortedKeys() []string
• type SyntaxError
• type SystemError
• type TableAttributeUnchangedError
  • func (e TableAttributeUnchangedError) Error() string
• type TableAttributeValueNotAllowedFormatError
• type TableFieldLengthError
• type TableNotLoadedError
• type TableObjectArgumentsLengthError
• type TableObjectInvalidArgumentError
• type TableObjectInvalidDelimiterError
• type TableObjectInvalidDelimiterPositionsError
• type TableObjectInvalidJsonQueryError
• type TableObjectJsonArgumentsLengthError
• type TemporaryTableFieldLengthError
• type TemporaryTableRedeclaredError
• type TemporaryViewScopes
  • func (list TemporaryViewScopes) All() ViewMap
  • func (list TemporaryViewScopes) Dispose(name parser.Identifier) error
  • func (list TemporaryViewScopes) Exists(name string) bool
  • func (list TemporaryViewScopes) Get(name parser.Identifier) (*View, error)
  • func (list TemporaryViewScopes) GetWithInternalId(ctx context.Context, name parser.Identifier, flags *cmd.Flags) (*View, error)
  • func (list TemporaryViewScopes) Replace(view *View)
  • func (list TemporaryViewScopes) Restore(uncomittedViews map[string]*FileInfo) []string
  • func (list TemporaryViewScopes) Set(view *View)
  • func (list TemporaryViewScopes) Store(uncomittedViews map[string]*FileInfo) []string
• type Transaction
  • func NewTransaction(ctx context.Context, defaultWaitTimeout time.Duration, ...) (*Transaction, error)
  • func (tx *Transaction) Commit(ctx context.Context, filter *Filter, expr parser.Expression) error
  • func (tx *Transaction) ReleaseResources() error
  • func (tx *Transaction) ReleaseResourcesWithErrors() error
  • func (tx *Transaction) Rollback(filter *Filter, expr parser.Expression) error
  • func (tx *Transaction) UpdateWaitTimeout(waitTimeout float64, retryDelay time.Duration)
• type UncommittedViews
  • func NewUncommittedViews() UncommittedViews
  • func (m *UncommittedViews) Clean()
  • func (m *UncommittedViews) CountCreatedTables() int
  • func (m *UncommittedViews) CountUpdatedTables() int
  • func (m *UncommittedViews) CountUpdatedViews() int
  • func (m *UncommittedViews) IsEmpty() bool
  • func (m *UncommittedViews) SetForCreatedView(fileInfo *FileInfo)
  • func (m *UncommittedViews) SetForUpdatedView(fileInfo *FileInfo)
  • func (m *UncommittedViews) UncommittedFiles() (map[string]*FileInfo, map[string]*FileInfo)
  • func (m *UncommittedViews) UncommittedTempViews() map[string]*FileInfo
  • func (m *UncommittedViews) Unset(fileInfo *FileInfo)
• type UndeclaredCursorError
• type UndeclaredTemporaryTableError
• type UndeclaredVariableError
• type UndefinedInLineTableError
• type UnknownFormatPlaceholderError
• type UnpermittedFunctionStatementError
• type UpdateFieldNotExistError
• type UpdateValueAmbiguousError
• type UserDefinedFunction
  • func (fn *UserDefinedFunction) CheckArgsLen(expr parser.QueryExpression, name string, argsLen int) error
  • func (fn *UserDefinedFunction) Execute(ctx context.Context, filter *Filter, args []value.Primary) (value.Primary, error)
  • func (fn *UserDefinedFunction) ExecuteAggregate(ctx context.Context, filter *Filter, values []value.Primary, ...) (value.Primary, error)
• type UserDefinedFunctionMap
  • func (m UserDefinedFunctionMap) CheckDuplicate(name parser.Identifier) error
  • func (m UserDefinedFunctionMap) Declare(expr parser.FunctionDeclaration) error
  • func (m UserDefinedFunctionMap) DeclareAggregate(expr parser.AggregateDeclaration) error
  • func (m UserDefinedFunctionMap) Dispose(name parser.Identifier) error
  • func (m UserDefinedFunctionMap) Get(fn parser.QueryExpression, name string) (*UserDefinedFunction, error)
  • func (m UserDefinedFunctionMap) Keys() []string
  • func (m UserDefinedFunctionMap) SortedKeys() []string
• type UserDefinedFunctionScopes
  • func (list UserDefinedFunctionScopes) All() (UserDefinedFunctionMap, UserDefinedFunctionMap)
  • func (list UserDefinedFunctionScopes) Declare(expr parser.FunctionDeclaration) error
  • func (list UserDefinedFunctionScopes) DeclareAggregate(expr parser.AggregateDeclaration) error
  • func (list UserDefinedFunctionScopes) Dispose(name parser.Identifier) error
  • func (list UserDefinedFunctionScopes) Get(expr parser.QueryExpression, name string) (*UserDefinedFunction, error)
• type UserTriggeredError
• type VariableMap
  • func NewVariableMap() VariableMap
  • func (m VariableMap) Add(variable parser.Variable, value value.Primary) error
  • func (m VariableMap) Declare(ctx context.Context, filter *Filter, declaration parser.VariableDeclaration) error
  • func (m VariableMap) Delete(name string)
  • func (m VariableMap) Dispose(variable parser.Variable) error
  • func (m VariableMap) Exists(name string) bool
  • func (m VariableMap) Get(variable parser.Variable) (value.Primary, error)
  • func (m VariableMap) Load(name string) (value.Primary, bool)
  • func (m VariableMap) Set(variable parser.Variable, value value.Primary) error
  • func (m VariableMap) Store(name string, value value.Primary)
  • func (m VariableMap) Substitute(ctx context.Context, filter *Filter, substitution parser.VariableSubstitution) (value.Primary, error)
  • func (m VariableMap) SubstituteDirectly(variable parser.Variable, value value.Primary) (value.Primary, error)
• type VariableRedeclaredError
• type VariableScopes
  • func (list VariableScopes) All() VariableMap
  • func (list VariableScopes) Declare(ctx context.Context, filter *Filter, expr parser.VariableDeclaration) error
  • func (list VariableScopes) Dispose(expr parser.Variable) error
  • func (list VariableScopes) Get(expr parser.Variable) (value value.Primary, err error)
  • func (list VariableScopes) Substitute(ctx context.Context, filter *Filter, expr parser.VariableSubstitution) (value value.Primary, err error)
  • func (list VariableScopes) SubstituteDirectly(variable parser.Variable, value value.Primary) (value.Primary, error)
• type View
  • func NewView(tx *Transaction) *View
  • func NewViewFromGroupedRecord(filterRecord filterRecord) *View
  • func Select(ctx context.Context, parentFilter *Filter, query parser.SelectQuery) (*View, error)
  • func (view *View) Copy() *View
  • func (view *View) Except(ctx context.Context, calcView *View, all bool) (err error)
  • func (view *View) ExtendRecordCapacity(ctx context.Context, exprs []parser.QueryExpression) error
  • func (view *View) FieldIndex(fieldRef parser.QueryExpression) (int, error)
  • func (view *View) FieldIndices(fields []parser.QueryExpression) ([]int, error)
  • func (view *View) FieldLen() int
  • func (view *View) FieldViewName(fieldRef parser.QueryExpression) (string, error)
  • func (view *View) Fix(ctx context.Context) error
  • func (view *View) GenerateComparisonKeys(ctx context.Context) error
  • func (view *View) GroupBy(ctx context.Context, clause parser.GroupByClause) error
  • func (view *View) Having(ctx context.Context, clause parser.HavingClause) error
  • func (view *View) InsertFromQuery(ctx context.Context, fields []parser.QueryExpression, query parser.SelectQuery) (int, error)
  • func (view *View) InsertValues(ctx context.Context, fields []parser.QueryExpression, ...) (int, error)
  • func (view *View) InternalRecordId(ref string, recordIndex int) (int, error)
  • func (view *View) Intersect(ctx context.Context, calcView *View, all bool) (err error)
  • func (view *View) Len() int
  • func (view *View) Less(i, j int) bool
  • func (view *View) Limit(ctx context.Context, clause parser.LimitClause) error
  • func (view *View) ListValuesForAggregateFunctions(ctx context.Context, expr parser.QueryExpression, arg parser.QueryExpression, ...) ([]value.Primary, error)
  • func (view *View) Load(ctx context.Context, filter *Filter, clause parser.FromClause, forUpdate bool, ...) error
  • func (view *View) LoadFromTableIdentifier(ctx context.Context, filter *Filter, table parser.QueryExpression, ...) error
  • func (view *View) Offset(ctx context.Context, clause parser.OffsetClause) error
  • func (view *View) OrderBy(ctx context.Context, clause parser.OrderByClause) error
  • func (view *View) RecordLen() int
  • func (view *View) RestoreHeaderReferences() error
  • func (view *View) Select(ctx context.Context, clause parser.SelectClause) error
  • func (view *View) SelectAllColumns(ctx context.Context) error
  • func (view *View) Swap(i, j int)
  • func (view *View) Union(ctx context.Context, calcView *View, all bool) (err error)
  • func (view *View) Where(ctx context.Context, clause parser.WhereClause) error
• type ViewMap
  • func NewViewMap() ViewMap
  • func (m ViewMap) Clean(container *file.Container) error
  • func (m ViewMap) CleanWithErrors(container *file.Container) error
  • func (m ViewMap) Delete(fpath string)
  • func (m ViewMap) Dispose(container *file.Container, name string) error
  • func (m ViewMap) DisposeTemporaryTable(table parser.Identifier) error
  • func (m ViewMap) Exists(fpath string) bool
  • func (m ViewMap) Get(fpath parser.Identifier) (*View, error)
  • func (m ViewMap) GetWithInternalId(ctx context.Context, fpath parser.Identifier, flags *cmd.Flags) (*View, error)
  • func (m ViewMap) Load(fpath string) (*View, bool)
  • func (m ViewMap) Set(view *View)
  • func (m ViewMap) Store(fpath string, view *View)
• type VirtualTerminal
  • func NewTerminal(ctx context.Context, filter *Filter) (VirtualTerminal, error)
• type WindowFrame
  • func WindowFrameSet(partition Partition, expr parser.AnalyticClause) []WindowFrame

Constants

const (
	ShowTables     = "TABLES"
	ShowViews      = "VIEWS"
	ShowCursors    = "CURSORS"
	ShowFunctions  = "FUNCTIONS"
	ShowStatements = "STATEMENTS"
	ShowFlags      = "FLAGS"
	ShowEnv        = "ENV"
	ShowRuninfo    = "RUNINFO"
)

const (
	ErrorMessageTemplate                 = "[L:%d C:%d] %s"
	ErrorMessageWithFilepathTemplate     = "%s [L:%d C:%d] %s"
	ErrorMessageWithCustomPrefixTemplate = "[%s] %s"

	ErrMsgIncorrectCommandUsage                = "incorrect usage: %s"
	ErrMsgInvalidValueExpression               = "%s: cannot evaluate as a value"
	ErrMsgInvalidPath                          = "%s: %s"
	ErrMsgIO                                   = "%s"
	ErrMsgCommit                               = "failed to commit: %s"
	ErrMsgRollback                             = "failed to rollback: %s"
	ErrMsgFieldAmbiguous                       = "field %s is ambiguous"
	ErrMsgFieldNotExist                        = "field %s does not exist"
	ErrMsgFieldNotGroupKey                     = "field %s is not a group key"
	ErrMsgDuplicateFieldName                   = "field name %s is a duplicate"
	ErrMsgNotGroupingRecords                   = "function %s cannot aggregate not grouping records"
	ErrMsgUndeclaredVariable                   = "variable %s is undeclared"
	ErrMsgVariableRedeclared                   = "variable %s is redeclared"
	ErrMsgFunctionNotExist                     = "function %s does not exist"
	ErrMsgFunctionArgumentsLength              = "function %s takes %s"
	ErrMsgFunctionInvalidArgument              = "%s for function %s"
	ErrMsgUnpermittedFunctionStatement         = "function %s cannot be used as a statement"
	ErrMsgNestedAggregateFunctions             = "aggregate functions are nested at %s"
	ErrMsgFunctionRedeclared                   = "function %s is redeclared"
	ErrMsgBuiltInFunctionDeclared              = "function %s is a built-in function"
	ErrMsgDuplicateParameter                   = "parameter %s is a duplicate"
	ErrMsgSubqueryTooManyRecords               = "subquery returns too many records, should return only one record"
	ErrMsgSubqueryTooManyFields                = "subquery returns too many fields, should return only one field"
	ErrMsgJsonQueryTooManyRecords              = "json query returns too many records, should return only one record"
	ErrMsgLoadJson                             = "json loading error: %s"
	ErrMsgEmptyJsonQuery                       = "json query is empty"
	ErrMsgEmptyJsonTable                       = "json table is empty"
	ErrMsgInvalidTableObject                   = "invalid table object: %s"
	ErrMsgTableObjectInvalidDelimiter          = "invalid delimiter: %s"
	ErrMsgTableObjectInvalidDelimiterPositions = "invalid delimiter positions: %s"
	ErrMsgTableObjectInvalidJsonQuery          = "invalid json query: %s"
	ErrMsgTableObjectArgumentsLength           = "table object %s takes at most %d arguments"
	ErrMsgTableObjectJsonArgumentsLength       = "table object %s takes exactly %d arguments"
	ErrMsgTableObjectInvalidArgument           = "invalid argument for %s: %s"
	ErrMsgCursorRedeclared                     = "cursor %s is redeclared"
	ErrMsgUndeclaredCursor                     = "cursor %s is undeclared"
	ErrMsgCursorClosed                         = "cursor %s is closed"
	ErrMsgCursorOpen                           = "cursor %s is already open"
	ErrMsgInvalidCursorStatement               = "invalid cursor statement: %s"
	ErrMsgPseudoCursor                         = "cursor %s is a pseudo cursor"
	ErrMsgCursorFetchLength                    = "fetching from cursor %s returns %s"
	ErrMsgInvalidFetchPosition                 = "fetching position %s is not an integer value"
	ErrMsgInlineTableRedefined                 = "inline table %s is redefined"
	ErrMsgUndefinedInlineTable                 = "inline table %s is undefined"
	ErrMsgInlineTableFieldLength               = "select query should return exactly %s for inline table %s"
	ErrMsgFileNotExist                         = "file %s does not exist"
	ErrMsgFileAlreadyExist                     = "file %s already exists"
	ErrMsgFileUnableToRead                     = "file %s is unable to be read"
	ErrMsgFileLockTimeout                      = "file %s: lock wait timeout period exceeded"
	ErrMsgFileNameAmbiguous                    = "filename %s is ambiguous"
	ErrMsgDataParsing                          = "data parse error in file %s: %s"
	ErrMsgTableFieldLength                     = "select query should return exactly %s for table %s"
	ErrMsgTemporaryTableRedeclared             = "view %s is redeclared"
	ErrMsgUndeclaredTemporaryTable             = "view %s is undeclared"
	ErrMsgTemporaryTableFieldLength            = "select query should return exactly %s for view %s"
	ErrMsgDuplicateTableName                   = "table name %s is a duplicate"
	ErrMsgTableNotLoaded                       = "table %s is not loaded"
	ErrMsgStdinEmpty                           = "stdin is empty"
	ErrMsgRowValueLengthInComparison           = "row value should contain exactly %s"
	ErrMsgFieldLengthInComparison              = "select query should return exactly %s"
	ErrMsgInvalidLimitPercentage               = "limit percentage %s is not a float value"
	ErrMsgInvalidLimitNumber                   = "limit number of records %s is not an integer value"
	ErrMsgInvalidOffsetNumber                  = "offset number %s is not an integer value"
	ErrMsgCombinedSetFieldLength               = "result set to be combined should contain exactly %s"
	ErrMsgInsertRowValueLength                 = "row value should contain exactly %s"
	ErrMsgInsertSelectFieldLength              = "select query should return exactly %s"
	ErrMsgUpdateFieldNotExist                  = "field %s does not exist in the tables to update"
	ErrMsgUpdateValueAmbiguous                 = "value %s to set in the field %s is ambiguous"
	ErrMsgDeleteTableNotSpecified              = "tables to delete records are not specified"
	ErrMsgShowInvalidObjectType                = "object type %s is invalid"
	ErrMsgReplaceValueLength                   = "%s"
	ErrMsgSourceInvalidFilePath                = "%s is a invalid file path"
	ErrMsgInvalidFlagName                      = "%s is an unknown flag"
	ErrMsgFlagValueNowAllowedFormat            = "%s for %s is not allowed"
	ErrMsgInvalidFlagValue                     = "%s"
	ErrMsgAddFlagNotSupportedName              = "add flag element syntax does not support %s"
	ErrMsgRemoveFlagNotSupportedName           = "remove flag element syntax does not support %s"
	ErrMsgInvalidFlagValueToBeRemoved          = "%s is an invalid value for %s to specify the element"
	ErrMsgInvalidRuntimeInformation            = "%s is an unknown runtime information"
	ErrMsgNotTable                             = "view has no attributes"
	ErrMsgInvalidTableAttributeName            = "table attribute %s does not exist"
	ErrMsgTableAttributeValueNotAllowedFormat  = "%s for %s is not allowed"
	ErrMsgInvalidTableAttributeValue           = "%s"
	ErrMsgInvalidEventName                     = "%s is an unknown event"
	ErrMsgInternalRecordIdNotExist             = "internal record id does not exist"
	ErrMsgInternalRecordIdEmpty                = "internal record id is empty"
	ErrMsgFieldLengthNotMatch                  = "field length does not match"
	ErrMsgRowValueLengthInList                 = "row value length does not match at index %d"
	ErrMsgFormatStringLengthNotMatch           = "number of replace values does not match"
	ErrMsgUnknownFormatPlaceholder             = "%q is an unknown placeholder"
	ErrMsgFormatUnexpectedTermination          = "unexpected termination of format string"
	ErrMsgExternalCommand                      = "external command: %s"
	ErrMsgInvalidReloadType                    = "%s is an unknown reload type"
	ErrMsgLoadConfiguration                    = "configuration loading error: %s"
	ErrMsgDuplicateStatementName               = "statement %s is a duplicate"
	ErrMsgStatementNotExist                    = "statement %s does not exist"
	ErrMsgStatementReplaceValueNotSpecified    = "replace value for %s is not specified"
)

const (
	ReturnCodeSystemError               = 1
	ReturnCodeIOError                   = 2
	ReturnCodeContextIsDone             = 4
	ReturnCodeSyntaxError               = 8
	ReturnCodeApplicationError          = 16
	ReturnCodeDefaultUserTriggeredError = 32
)

const (
	//System Error
	ErrorSystemError     = 1000
	ErrorExternalCommand = 1100

	//IO Error
	ErrorIO               = 2000
	ErrorCommit           = 2100
	ErrorRollback         = 2101
	ErrorInvalidPath      = 2200
	ErrorFileNotExist     = 2201
	ErrorFileAlreadyExist = 2202
	ErrorFileUnableToRead = 2203

	//Context Error
	ErrorContextIsDone   = 4000
	ErrorFileLockTimeout = 4001

	//Syntax Error
	ErrorSyntaxError                  = 8000
	ErrorInvalidValueExpression       = 8001
	ErrorUnpermittedFunctionStatement = 8002
	ErrorNestedAggregateFunctions     = 8003
	ErrorPreparedStatementSyntaxError = 8004

	//Application Error
	ErrorFieldAmbiguous                       = 16001
	ErrorFieldNotExist                        = 16002
	ErrorFieldNotGroupKey                     = 16003
	ErrorDuplicateFieldName                   = 16004
	ErrorNotGroupingRecords                   = 16101
	ErrorUndeclaredVariable                   = 16201
	ErrorVariableRedeclared                   = 16202
	ErrorFunctionNotExist                     = 16301
	ErrorFunctionArgumentsLength              = 16302
	ErrorFunctionInvalidArgument              = 16303
	ErrorFunctionRedeclared                   = 16401
	ErrorBuiltInFunctionDeclared              = 16402
	ErrorDuplicateParameter                   = 16403
	ErrorSubqueryTooManyRecords               = 16501
	ErrorSubqueryTooManyFields                = 16502
	ErrorJsonQueryTooManyRecords              = 16601
	ErrorLoadJson                             = 16602
	ErrorEmptyJsonQuery                       = 16603
	ErrorEmptyJsonTable                       = 16701
	ErrorInvalidTableObject                   = 16801
	ErrorTableObjectInvalidDelimiter          = 16802
	ErrorTableObjectInvalidDelimiterPositions = 16803
	ErrorTableObjectInvalidJsonQuery          = 16804
	ErrorTableObjectArgumentsLength           = 16805
	ErrorTableObjectJsonArgumentsLength       = 16806
	ErrorTableObjectInvalidArgument           = 16807
	ErrorCursorRedeclared                     = 16901
	ErrorUndeclaredCursor                     = 16902
	ErrorCursorClosed                         = 16903
	ErrorCursorOpen                           = 16904
	ErrorInvalidCursorStatement               = 16905
	ErrorPseudoCursor                         = 16906
	ErrorCursorFetchLength                    = 16907
	ErrorInvalidFetchPosition                 = 16908
	ErrorInlineTableRedefined                 = 17001
	ErrorUndefinedInlineTable                 = 17002
	ErrorInlineTableFieldLength               = 17003
	ErrorFileNameAmbiguous                    = 17101
	ErrorDataParsing                          = 17201
	ErrorTableFieldLength                     = 17301
	ErrorTemporaryTableRedeclared             = 17401
	ErrorUndeclaredTemporaryTable             = 17402
	ErrorTemporaryTableFieldLength            = 17403
	ErrorDuplicateTableName                   = 17501
	ErrorTableNotLoaded                       = 17502
	ErrorStdinEmpty                           = 17503
	ErrorRowValueLengthInComparison           = 17601
	ErrorFieldLengthInComparison              = 17602
	ErrorInvalidLimitPercentage               = 17701
	ErrorInvalidLimitNumber                   = 17702
	ErrorInvalidOffsetNumber                  = 17801
	ErrorCombinedSetFieldLength               = 17901
	ErrorInsertRowValueLength                 = 18001
	ErrorInsertSelectFieldLength              = 18002
	ErrorUpdateFieldNotExist                  = 19001
	ErrorUpdateValueAmbiguous                 = 19002
	ErrorDeleteTableNotSpecified              = 19101
	ErrorShowInvalidObjectType                = 19201
	ErrorReplaceValueLength                   = 19301
	ErrorSourceInvalidFilePath                = 19401
	ErrorInvalidFlagName                      = 19501
	ErrorFlagValueNowAllowedFormat            = 19502
	ErrorInvalidFlagValue                     = 19503
	ErrorAddFlagNotSupportedName              = 19601
	ErrorRemoveFlagNotSupportedName           = 19602
	ErrorInvalidFlagValueToBeRemoved          = 19603
	ErrorInvalidRuntimeInformation            = 19701
	ErrorNotTable                             = 19801
	ErrorInvalidTableAttributeName            = 19802
	ErrorTableAttributeValueNotAllowedFormat  = 19803
	ErrorInvalidTableAttributeValue           = 19804
	ErrorInvalidEventName                     = 19901
	ErrorInternalRecordIdNotExist             = 20001
	ErrorInternalRecordIdEmpty                = 20002
	ErrorFieldLengthNotMatch                  = 20101
	ErrorRowValueLengthInList                 = 20201
	ErrorFormatStringLengthNotMatch           = 20301
	ErrorUnknownFormatPlaceholder             = 20302
	ErrorFormatUnexpectedTermination          = 20303
	ErrorInvalidReloadType                    = 20401
	ErrorLoadConfiguration                    = 20501
	ErrorDuplicateStatementName               = 20601
	ErrorStatementNotExist                    = 20602
	ErrorStatementReplaceValueNotSpecified    = 20603

	ErrorIncorrectCommandUsage = 30000

	//User Triggered Error
	ErrorExit          = 32000
	ErrorUserTriggered = 32001
)

const (
	TableDelimiter          = "DELIMITER"
	TableDelimiterPositions = "DELIMITER_POSITIONS"
	TableFormat             = "FORMAT"
	TableEncoding           = "ENCODING"
	TableLineBreak          = "LINE_BREAK"
	TableHeader             = "HEADER"
	TableEncloseAll         = "ENCLOSE_ALL"
	TableJsonEscape         = "JSON_ESCAPE"
	TablePrettyPrint        = "PRETTY_PRINT"
)

const (
	DefaultLineWidth = 75
	DefaultPadding   = 1
)

const (
	UncommittedInformation  = "UNCOMMITTED"
	CreatedInformation      = "CREATED"
	UpdatedInformation      = "UPDATED"
	UpdatedViewsInformation = "UPDATED_VIEWS"
	LoadedTablesInformation = "LOADED_TABLES"
	WorkingDirectory        = "WORKING_DIRECTORY"
	VersionInformation      = "VERSION"
)

const (
	TerminalPrompt           string = "csvq > "
	TerminalContinuousPrompt string = "     > "
)

const DefaultUserTriggeredErrorMessage = "triggered error"

const EOF = -1

const ExitMessage = "exit"

const IgnoredFlagPrefix = "(ignored) "

const InternalIdColumn = "@__internal_id"

const MinimumRequiredPerCPUCore = 80

const (
	ReloadConfig = "CONFIG"
)

const StatementReplaceValuesContextKey = "statement_replace_values"

const StoringResultsContextKey = "store_query_results"

Variables

var AggregateFunctions = map[string]AggregateFunction{
	"COUNT":  Count,
	"MAX":    Max,
	"MIN":    Min,
	"SUM":    Sum,
	"AVG":    Avg,
	"MEDIAN": Median,
}

var AnalyticFunctions = map[string]AnalyticFunction{
	"ROW_NUMBER":   RowNumber{},
	"RANK":         Rank{},
	"DENSE_RANK":   DenseRank{},
	"CUME_DIST":    CumeDist{},
	"PERCENT_RANK": PercentRank{},
	"NTILE":        NTile{},
	"FIRST_VALUE":  FirstValue{},
	"LAST_VALUE":   LastValue{},
	"NTH_VALUE":    NthValue{},
	"LAG":          Lag{},
	"LEAD":         Lead{},
	"LISTAGG":      AnalyticListAgg{},
	"JSON_AGG":     AnalyticJsonAgg{},
}

var FileAttributeList = []string{
	TableDelimiter,
	TableDelimiterPositions,
	TableFormat,
	TableEncoding,
	TableLineBreak,
	TableHeader,
	TableEncloseAll,
	TableJsonEscape,
	TablePrettyPrint,
}

var Functions = map[string]func(parser.Function, []value.Primary, *cmd.Flags) (value.Primary, error){}/* 105 elements not displayed */

var RuntimeInformatinList = []string{
	UncommittedInformation,
	CreatedInformation,
	UpdatedInformation,
	UpdatedViewsInformation,
	LoadedTablesInformation,
	WorkingDirectory,
	VersionInformation,
}

var ShowObjectList = []string{
	ShowTables,
	ShowViews,
	ShowCursors,
	ShowFunctions,
	ShowStatements,
	ShowFlags,
	ShowEnv,
	ShowRuninfo,
}

var Version = "v1.9.8"

Functions

func Abs

func Abs(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Acos

func Acos(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func AddDay

func AddDay(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func AddFlagElement

func AddFlagElement(ctx context.Context, filter *Filter, expr parser.AddFlagElement) error

func AddHour

func AddHour(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func AddMicro

func AddMicro(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func AddMilli

func AddMilli(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func AddMinute

func AddMinute(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func AddMonth

func AddMonth(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func AddNano

func AddNano(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func AddSecond

func AddSecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func AddYear

func AddYear(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func All

func All(rowValue value.RowValue, list []value.RowValue, operator string, datetimeFormats []string) (ternary.Value, error)

func Analyze

func Analyze(ctx context.Context, view *View, fn parser.AnalyticFunction, partitionIndices []int) error

func Any

func Any(rowValue value.RowValue, list []value.RowValue, operator string, datetimeFormats []string) (ternary.Value, error)

func Asin

func Asin(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Atan

func Atan(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Atan2

func Atan2(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Avg

func Avg(list []value.Primary, _ *cmd.Flags) value.Primary

func Base64Decode

func Base64Decode(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Base64Encode

func Base64Encode(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Bin

func Bin(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func BinToDec

func BinToDec(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Boolean

func Boolean(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func ByteLen

func ByteLen(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func CalcMinimumRequired

func CalcMinimumRequired(i1 int, i2 int, defaultMinimumRequired int) int

func Calculate

func Calculate(p1 value.Primary, p2 value.Primary, operator int) value.Primary

func Call

func Call(ctx context.Context, fn parser.Function, args []value.Primary) (value.Primary, error)

func Ceil

func Ceil(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Chdir

func Chdir(ctx context.Context, filter *Filter, expr parser.Chdir) error

func CheckArgsLen

func CheckArgsLen(expr parser.AnalyticFunction, length []int) error

func Coalesce

func Coalesce(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func ContextForPreparedStatement

func ContextForPreparedStatement(ctx context.Context, values *ReplaceValues) context.Context

func ContextForStoringResults

func ContextForStoringResults(ctx context.Context) context.Context

func ConvertFieldContents

func ConvertFieldContents(val value.Primary, forTextTable bool) (string, string, text.FieldAlignment)

func ConvertFileHandlerError

func ConvertFileHandlerError(err error, ident parser.Identifier) error

func ConvertLoadConfigurationError

func ConvertLoadConfigurationError(err error) error

func Cos

func Cos(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Count

func Count(list []value.Primary, _ *cmd.Flags) value.Primary

func CreateFilePath

func CreateFilePath(filename parser.Identifier, repository string) (string, error)

func CrossJoin

func CrossJoin(ctx context.Context, filter *Filter, view *View, joinView *View) error

func DateDiff

func DateDiff(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Datetime

func Datetime(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func DatetimeFormat

func DatetimeFormat(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Day

func Day(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func DayOfYear

func DayOfYear(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func DeclareView

func DeclareView(ctx context.Context, filter *Filter, expr parser.ViewDeclaration) error

func Distinguish

func Distinguish(list []value.Primary, flags *cmd.Flags) []value.Primary

func Echo

func Echo(ctx context.Context, filter *Filter, expr parser.Echo) (string, error)

func EncodeView

func EncodeView(ctx context.Context, fp io.Writer, view *View, fileInfo *FileInfo, flags *cmd.Flags) (string, error)

func Enotation

func Enotation(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func EnotationToDec

func EnotationToDec(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Exp

func Exp(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Exp2

func Exp2(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Expm1

func Expm1(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func FetchCursor

func FetchCursor(ctx context.Context, filter *Filter, name parser.Identifier, fetchPosition parser.FetchPosition, vars []parser.Variable) (bool, error)

func Float

func Float(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Floor

func Floor(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Format

func Format(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func FormatCount

func FormatCount(i int, obj string) string

func GetRuntimeInformation

func GetRuntimeInformation(tx *Transaction, expr parser.RuntimeInformation) (value.Primary, error)

func Hex

func Hex(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func HexDecode

func HexDecode(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func HexEncode

func HexEncode(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func HexToDec

func HexToDec(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func HistoryFilePath

func HistoryFilePath(filename string) (string, error)

func Hour

func Hour(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func If

func If(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Ifnull

func Ifnull(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func InIntSlice

func InIntSlice(i int, list []int) bool

func InRowValueList

func InRowValueList(rowValue value.RowValue, list []value.RowValue, matchType int, operator string, datetimeFormats []string) (ternary.Value, error)

func InStrSliceWithCaseInsensitive

func InStrSliceWithCaseInsensitive(s string, list []string) bool

func InnerJoin

func InnerJoin(ctx context.Context, parentFilter *Filter, view *View, joinView *View, condition parser.QueryExpression) error

func Instr

func Instr(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Integer

func Integer(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Is

func Is(p1 value.Primary, p2 value.Primary) ternary.Value

func JsonAgg

func JsonAgg(list []value.Primary) value.Primary

func JsonObject

func JsonObject(ctx context.Context, filter *Filter, fn parser.Function) (value.Primary, error)

func JsonValue

func JsonValue(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Len

func Len(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Like

func Like(p1 value.Primary, p2 value.Primary) ternary.Value

func ListAgg

func ListAgg(list []value.Primary, separator string) value.Primary

func ListElem

func ListElem(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func LoadContentsFromFile

func LoadContentsFromFile(ctx context.Context, tx *Transaction, fpath parser.Identifier) (content string, err error)

func LoadStatementsFromFile

func LoadStatementsFromFile(ctx context.Context, tx *Transaction, fpath parser.Identifier) (statements []parser.Statement, err error)

func Log10

func Log10(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Log1p

func Log1p(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Log2

func Log2(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Lower

func Lower(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Lpad

func Lpad(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Ltrim

func Ltrim(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func MathLog

func MathLog(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Max

func Max(list []value.Primary, flags *cmd.Flags) value.Primary

func Md5

func Md5(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Md5Hmac

func Md5Hmac(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Median

func Median(list []value.Primary, flags *cmd.Flags) value.Primary

func Microsecond

func Microsecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Millisecond

func Millisecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Min

func Min(list []value.Primary, flags *cmd.Flags) value.Primary

func Minute

func Minute(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Month

func Month(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Nanosecond

func Nanosecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func NewAddFlagNotSupportedNameError

func NewAddFlagNotSupportedNameError(expr parser.AddFlagElement) error

func NewBuiltInFunctionDeclaredError

func NewBuiltInFunctionDeclaredError(expr parser.Identifier) error

func NewCombinedSetFieldLengthError

func NewCombinedSetFieldLengthError(selectEntity parser.QueryExpression, fieldLen int) error

func NewCommitError

func NewCommitError(expr parser.Expression, message string) error

func NewContextIsDone

func NewContextIsDone(message string) error

func NewCursorClosedError

func NewCursorClosedError(cursor parser.Identifier) error

func NewCursorFetchLengthError

func NewCursorFetchLengthError(cursor parser.Identifier, returnLen int) error

func NewCursorOpenError

func NewCursorOpenError(cursor parser.Identifier) error

func NewCursorRedeclaredError

func NewCursorRedeclaredError(cursor parser.Identifier) error

func NewDataParsingError

func NewDataParsingError(file parser.QueryExpression, filepath string, message string) error

func NewDeleteTableNotSpecifiedError

func NewDeleteTableNotSpecifiedError(query parser.DeleteQuery) error

func NewDuplicateFieldNameError

func NewDuplicateFieldNameError(fieldName parser.Identifier) error

func NewDuplicateParameterError

func NewDuplicateParameterError(expr parser.Variable) error

func NewDuplicateStatementNameError

func NewDuplicateStatementNameError(name parser.Identifier) error

func NewDuplicateTableNameError

func NewDuplicateTableNameError(table parser.Identifier) error

func NewEmptyJsonQueryError

func NewEmptyJsonQueryError(expr parser.JsonQuery) error

func NewEmptyJsonTableError

func NewEmptyJsonTableError(expr parser.JsonQuery) error

func NewExternalCommandError

func NewExternalCommandError(expr parser.Expression, message string) error

func NewFieldAmbiguousError

func NewFieldAmbiguousError(field parser.QueryExpression) error

func NewFieldLengthNotMatchError

func NewFieldLengthNotMatchError() error

func NewFieldNotExistError

func NewFieldNotExistError(field parser.QueryExpression) error

func NewFieldNotGroupKeyError

func NewFieldNotGroupKeyError(field parser.QueryExpression) error

func NewFileAlreadyExistError

func NewFileAlreadyExistError(file parser.Identifier) error

func NewFileLockTimeoutError

func NewFileLockTimeoutError(file parser.Identifier) error

func NewFileNameAmbiguousError

func NewFileNameAmbiguousError(file parser.Identifier) error

func NewFileNotExistError

func NewFileNotExistError(file parser.QueryExpression) error

func NewFileUnableToReadError

func NewFileUnableToReadError(file parser.Identifier) error

func NewFlagValueNotAllowedFormatError

func NewFlagValueNotAllowedFormatError(setFlag parser.SetFlag) error

func NewForcedExit

func NewForcedExit(code int) error

func NewFormatStringLengthNotMatchError

func NewFormatStringLengthNotMatchError() error

func NewFormatUnexpectedTerminationError

func NewFormatUnexpectedTerminationError() error

func NewFunctionArgumentLengthError

func NewFunctionArgumentLengthError(expr parser.QueryExpression, funcname string, argslen []int) error

func NewFunctionArgumentLengthErrorWithCustomArgs

func NewFunctionArgumentLengthErrorWithCustomArgs(expr parser.QueryExpression, funcname string, argstr string) error

func NewFunctionInvalidArgumentError

func NewFunctionInvalidArgumentError(function parser.QueryExpression, funcname string, message string) error

func NewFunctionNotExistError

func NewFunctionNotExistError(expr parser.QueryExpression, funcname string) error

func NewFunctionRedeclaredError

func NewFunctionRedeclaredError(expr parser.Identifier) error

func NewIOError

func NewIOError(expr parser.Expression, message string) error

func NewInLineTableRedefinedError

func NewInLineTableRedefinedError(table parser.Identifier) error

func NewIncorrectCommandUsageError

func NewIncorrectCommandUsageError(message string) error

func NewInlineTableFieldLengthError

func NewInlineTableFieldLengthError(query parser.SelectQuery, table parser.Identifier, fieldLen int) error

func NewInsertRowValueLengthError

func NewInsertRowValueLengthError(rowValue parser.RowValue, valueLen int) error

func NewInsertSelectFieldLengthError

func NewInsertSelectFieldLengthError(query parser.SelectQuery, fieldLen int) error

func NewInternalRecordIdEmptyError

func NewInternalRecordIdEmptyError() error

func NewInternalRecordIdNotExistError

func NewInternalRecordIdNotExistError() error

func NewInvalidCursorStatementError

func NewInvalidCursorStatementError(statement parser.Identifier) error

func NewInvalidEventNameError

func NewInvalidEventNameError(expr parser.Identifier) error

func NewInvalidFetchPositionError

func NewInvalidFetchPositionError(position parser.FetchPosition) error

func NewInvalidFlagNameError

func NewInvalidFlagNameError(expr parser.Expression, name string) error

func NewInvalidFlagValueError

func NewInvalidFlagValueError(expr parser.SetFlag, message string) error

func NewInvalidFlagValueToBeRemovedError

func NewInvalidFlagValueToBeRemovedError(unsetFlag parser.RemoveFlagElement) error

func NewInvalidLimitNumberError

func NewInvalidLimitNumberError(clause parser.LimitClause) error

func NewInvalidLimitPercentageError

func NewInvalidLimitPercentageError(clause parser.LimitClause) error

func NewInvalidOffsetNumberError

func NewInvalidOffsetNumberError(clause parser.OffsetClause) error

func NewInvalidPathError

func NewInvalidPathError(expr parser.Expression, path string, message string) error

func NewInvalidReloadTypeError

func NewInvalidReloadTypeError(expr parser.Reload, name string) error

func NewInvalidRuntimeInformationError

func NewInvalidRuntimeInformationError(expr parser.RuntimeInformation) error

func NewInvalidTableAttributeNameError

func NewInvalidTableAttributeNameError(expr parser.Identifier) error

func NewInvalidTableAttributeValueError

func NewInvalidTableAttributeValueError(expr parser.SetTableAttribute, message string) error

func NewInvalidTableObjectError

func NewInvalidTableObjectError(expr parser.TableObject, objectName string) error

func NewInvalidValueExpressionError

func NewInvalidValueExpressionError(expr parser.QueryExpression) error

func NewJsonQueryTooManyRecordsError

func NewJsonQueryTooManyRecordsError(expr parser.JsonQuery) error

func NewLoadConfigurationError

func NewLoadConfigurationError(expr parser.Expression, message string) error

func NewLoadJsonError

func NewLoadJsonError(expr parser.JsonQuery, message string) error

func NewNestedAggregateFunctionsError

func NewNestedAggregateFunctionsError(expr parser.QueryExpression) error

func NewNotGroupingRecordsError

func NewNotGroupingRecordsError(expr parser.QueryExpression, funcname string) error

func NewNotTableError

func NewNotTableError(expr parser.QueryExpression) error

func NewPreparedStatementSyntaxError

func NewPreparedStatementSyntaxError(err *parser.SyntaxError) error

func NewPromptEvaluationError

func NewPromptEvaluationError(message string) error

func NewPseudoCursorError

func NewPseudoCursorError(cursor parser.Identifier) error

func NewRemoveFlagNotSupportedNameError

func NewRemoveFlagNotSupportedNameError(expr parser.RemoveFlagElement) error

func NewReplaceValueLengthError

func NewReplaceValueLengthError(expr parser.Expression, message string) error

func NewRollbackError

func NewRollbackError(expr parser.Expression, message string) error

func NewRowValueLengthInComparisonError

func NewRowValueLengthInComparisonError(expr parser.QueryExpression, valueLen int) error

func NewRowValueLengthInListError

func NewRowValueLengthInListError(i int) error

func NewSelectFieldLengthInComparisonError

func NewSelectFieldLengthInComparisonError(query parser.Subquery, valueLen int) error

func NewShowInvalidObjectTypeError

func NewShowInvalidObjectTypeError(expr parser.Expression, objectType string) error

func NewSourceInvalidFilePathError

func NewSourceInvalidFilePathError(source parser.Source, arg parser.QueryExpression) error

func NewStatementNotExistError

func NewStatementNotExistError(name parser.Identifier) error

func NewStatementReplaceValueNotSpecifiedError

func NewStatementReplaceValueNotSpecifiedError(placeholder parser.Placeholder) error

func NewStdinEmptyError

func NewStdinEmptyError(stdin parser.Stdin) error

func NewSubqueryTooManyFieldsError

func NewSubqueryTooManyFieldsError(expr parser.Subquery) error

func NewSubqueryTooManyRecordsError

func NewSubqueryTooManyRecordsError(expr parser.Subquery) error

func NewSyntaxError

func NewSyntaxError(err *parser.SyntaxError) error

func NewSystemError

func NewSystemError(message string) error

func NewTableAttributeUnchangedError

func NewTableAttributeUnchangedError(fpath string) error

func NewTableAttributeValueNotAllowedFormatError

func NewTableAttributeValueNotAllowedFormatError(expr parser.SetTableAttribute) error

func NewTableFieldLengthError

func NewTableFieldLengthError(query parser.SelectQuery, table parser.Identifier, fieldLen int) error

func NewTableNotLoadedError

func NewTableNotLoadedError(table parser.Identifier) error

func NewTableObjectArgumentsLengthError

func NewTableObjectArgumentsLengthError(expr parser.TableObject, argLen int) error

func NewTableObjectInvalidArgumentError

func NewTableObjectInvalidArgumentError(expr parser.TableObject, message string) error

func NewTableObjectInvalidDelimiterError

func NewTableObjectInvalidDelimiterError(expr parser.TableObject, delimiter string) error

func NewTableObjectInvalidDelimiterPositionsError

func NewTableObjectInvalidDelimiterPositionsError(expr parser.TableObject, positions string) error

func NewTableObjectInvalidJsonQueryError

func NewTableObjectInvalidJsonQueryError(expr parser.TableObject, jsonQuery string) error

func NewTableObjectJsonArgumentsLengthError

func NewTableObjectJsonArgumentsLengthError(expr parser.TableObject, argLen int) error

func NewTemporaryTableFieldLengthError

func NewTemporaryTableFieldLengthError(query parser.SelectQuery, table parser.Identifier, fieldLen int) error

func NewTemporaryTableRedeclaredError

func NewTemporaryTableRedeclaredError(table parser.Identifier) error

func NewUndeclaredCursorError

func NewUndeclaredCursorError(cursor parser.Identifier) error

func NewUndeclaredTemporaryTableError

func NewUndeclaredTemporaryTableError(table parser.Identifier) error

func NewUndeclaredVariableError

func NewUndeclaredVariableError(expr parser.Variable) error

func NewUndefinedInLineTableError

func NewUndefinedInLineTableError(table parser.Identifier) error

func NewUnknownFormatPlaceholderError

func NewUnknownFormatPlaceholderError(placeholder rune) error

func NewUnpermittedFunctionStatementError

func NewUnpermittedFunctionStatementError(expr parser.QueryExpression, funcname string) error

func NewUpdateFieldNotExistError

func NewUpdateFieldNotExistError(field parser.QueryExpression) error

func NewUpdateValueAmbiguousError

func NewUpdateValueAmbiguousError(field parser.QueryExpression, value parser.QueryExpression) error

func NewUserTriggeredError

func NewUserTriggeredError(expr parser.Trigger, message string) error

func NewVariableRedeclaredError

func NewVariableRedeclaredError(expr parser.Variable) error

func Now

func Now(filter *Filter, fn parser.Function, args []value.Primary) (value.Primary, error)

func Nullif

func Nullif(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func NumberFormat

func NumberFormat(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Oct

func Oct(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func OctToDec

func OctToDec(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func OuterJoin

func OuterJoin(ctx context.Context, parentFilter *Filter, view *View, joinView *View, condition parser.QueryExpression, direction int) error

func ParseExecuteStatements

func ParseExecuteStatements(ctx context.Context, filter *Filter, expr parser.Execute) ([]parser.Statement, error)

func ParseJoinCondition

func ParseJoinCondition(join parser.Join, view *View, joinView *View) (parser.QueryExpression, []parser.FieldReference, []parser.FieldReference, error)

func Pow

func Pow(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Print

func Print(ctx context.Context, filter *Filter, expr parser.Print) (string, error)

func Printf

func Printf(ctx context.Context, filter *Filter, expr parser.Printf) (string, error)

func Pwd

func Pwd(expr parser.Pwd) (string, error)

func Rand

func Rand(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Reload

func Reload(ctx context.Context, tx *Transaction, expr parser.Reload) error

func RemoveFlagElement

func RemoveFlagElement(ctx context.Context, filter *Filter, expr parser.RemoveFlagElement) error

func Replace

func Replace(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Round

func Round(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Rpad

func Rpad(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Rtrim

func Rtrim(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func SearchCSVFilePath

func SearchCSVFilePath(filename parser.Identifier, repository string) (string, error)

func SearchFilePath

func SearchFilePath(filename parser.Identifier, repository string, format cmd.Format, flags *cmd.Flags) (string, cmd.Format, error)

func SearchFilePathFromAllTypes

func SearchFilePathFromAllTypes(filename parser.Identifier, repository string) (string, error)

func SearchFilePathWithExtType

func SearchFilePathWithExtType(filename parser.Identifier, repository string, extTypes []string) (string, error)

func SearchFixedLengthFilePath

func SearchFixedLengthFilePath(filename parser.Identifier, repository string) (string, error)

func SearchJsonFilePath

func SearchJsonFilePath(filename parser.Identifier, repository string) (string, error)

func SearchLTSVFilePath

func SearchLTSVFilePath(filename parser.Identifier, repository string) (string, error)

func Second

func Second(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func SerializeComparisonKeys

func SerializeComparisonKeys(buf *bytes.Buffer, values []value.Primary, flags *cmd.Flags)

func SerializeKey

func SerializeKey(buf *bytes.Buffer, val value.Primary, flags *cmd.Flags)

func SetEnvVar

func SetEnvVar(ctx context.Context, filter *Filter, expr parser.SetEnvVar) error

func SetFlag

func SetFlag(ctx context.Context, filter *Filter, expr parser.SetFlag) error

func Sha1

func Sha1(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Sha1Hmac

func Sha1Hmac(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Sha256

func Sha256(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Sha256Hmac

func Sha256Hmac(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Sha512

func Sha512(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Sha512Hmac

func Sha512Hmac(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func ShowFields

func ShowFields(ctx context.Context, filter *Filter, expr parser.ShowFields) (string, error)

func ShowFlag

func ShowFlag(flags *cmd.Flags, expr parser.ShowFlag) (string, error)

func ShowObjects

func ShowObjects(filter *Filter, expr parser.ShowObjects) (string, error)

func Sin

func Sin(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Source

func Source(ctx context.Context, filter *Filter, expr parser.Source) ([]parser.Statement, error)

func Sqrt

func Sqrt(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func String

func String(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Substr

func Substr(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Sum

func Sum(list []value.Primary, _ *cmd.Flags) value.Primary

func Syntax

func Syntax(ctx context.Context, filter *Filter, expr parser.Syntax) string

func Tan

func Tan(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func Ternary

func Ternary(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func TimeDiff

func TimeDiff(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func TimeNanoDiff

func TimeNanoDiff(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Trim

func Trim(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func TruncDay

func TruncDay(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func TruncMicro

func TruncMicro(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func TruncMilli

func TruncMilli(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func TruncMinute

func TruncMinute(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func TruncMonth

func TruncMonth(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func TruncNano

func TruncNano(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func TruncSecond

func TruncSecond(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func TruncTime

func TruncTime(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func UTC

func UTC(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func UnixNanoTime

func UnixNanoTime(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func UnixTime

func UnixTime(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func UnsetEnvVar

func UnsetEnvVar(expr parser.UnsetEnvVar) error

func Upper

func Upper(fn parser.Function, args []value.Primary, _ *cmd.Flags) (value.Primary, error)

func WeekOfYear

func WeekOfYear(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Weekday

func Weekday(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Width

func Width(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

func Year

func Year(fn parser.Function, args []value.Primary, flags *cmd.Flags) (value.Primary, error)

Types

type AddFlagNotSupportedNameError

type AddFlagNotSupportedNameError struct {
	*BaseError
}

type AggregateFunction

type AggregateFunction func([]value.Primary, *cmd.Flags) value.Primary

type AliasMap

type AliasMap map[string]string

func (AliasMap) Add

func (m AliasMap) Add(alias parser.Identifier, path string) error

func (AliasMap) Get

func (m AliasMap) Get(alias parser.Identifier) (string, error)

type AliasNodes

type AliasNodes []AliasMap

func (AliasNodes) Add

func (list AliasNodes) Add(alias parser.Identifier, path string) error

func (AliasNodes) Get

func (list AliasNodes) Get(alias parser.Identifier) (path string, err error)

type AnalyticFunction

type AnalyticFunction interface {
	CheckArgsLen(expr parser.AnalyticFunction) error
	Execute(context.Context, *Filter, Partition, parser.AnalyticFunction) (map[int]value.Primary, error)
}

type AnalyticJsonAgg

type AnalyticJsonAgg struct{}

func (AnalyticJsonAgg) CheckArgsLen

func (fn AnalyticJsonAgg) CheckArgsLen(expr parser.AnalyticFunction) error

func (AnalyticJsonAgg) Execute

func (fn AnalyticJsonAgg) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type AnalyticListAgg

type AnalyticListAgg struct{}

func (AnalyticListAgg) CheckArgsLen

func (fn AnalyticListAgg) CheckArgsLen(expr parser.AnalyticFunction) error

func (AnalyticListAgg) Execute

func (fn AnalyticListAgg) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type BaseError

type BaseError struct {
	// contains filtered or unexported fields
}

func NewBaseError

func NewBaseError(expr parser.Expression, message string, code int, number int) *BaseError

func NewBaseErrorWithPrefix

func NewBaseErrorWithPrefix(prefix string, message string, code int, number int) *BaseError

func (*BaseError) Char

func (e *BaseError) Char() int

func (*BaseError) Code

func (e *BaseError) Code() int

func (*BaseError) Error

func (e *BaseError) Error() string

func (*BaseError) Line

func (e *BaseError) Line() int

func (*BaseError) Message

func (e *BaseError) Message() string

func (*BaseError) Number

func (e *BaseError) Number() int

func (*BaseError) Source

func (e *BaseError) Source() string

type BuiltInFunctionDeclaredError

type BuiltInFunctionDeclaredError struct {
	*BaseError
}

type Cell

type Cell []value.Primary

func NewCell

func NewCell(val value.Primary) Cell

func NewGroupCell

func NewGroupCell(values []value.Primary) Cell

func (Cell) GroupedValue

func (cell Cell) GroupedValue(index int) value.Primary

func (Cell) Len

func (cell Cell) Len() int

func (Cell) Value

func (cell Cell) Value() value.Primary

type CombinedSetFieldLengthError

type CombinedSetFieldLengthError struct {
	*BaseError
}

type CommitError

type CommitError struct {
	*BaseError
}

type Completer

type Completer struct {
	// contains filtered or unexported fields
}

func NewCompleter

func NewCompleter(filter *Filter) *Completer

func (*Completer) AddFlagArgs

func (c *Completer) AddFlagArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) AllColumnList

func (c *Completer) AllColumnList() []string

func (*Completer) AlterArgs

func (c *Completer) AlterArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) BracketIsEnclosed

func (c *Completer) BracketIsEnclosed() bool

func (*Completer) CaseExpression

func (c *Completer) CaseExpression(line string, origLine string, index int) readline.CandidateList

func (*Completer) ColumnList

func (c *Completer) ColumnList(tableName string, repository string) []string

func (*Completer) CreateArgs

func (c *Completer) CreateArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) CursorStatus

func (c *Completer) CursorStatus(line string, origLine string, index int) readline.CandidateList

func (*Completer) DeclareArgs

func (c *Completer) DeclareArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) DeleteArgs

func (c *Completer) DeleteArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) DisposeArgs

func (c *Completer) DisposeArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) Do

func (c *Completer) Do(line []rune, pos int, index int) (readline.CandidateList, int)

func (*Completer) EncloseQuotation

func (c *Completer) EncloseQuotation(line string, origLine string, index int) readline.CandidateList

func (*Completer) FetchArgs

func (c *Completer) FetchArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) FunctionArgs

func (c *Completer) FunctionArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) GetStatementPrefix

func (c *Completer) GetStatementPrefix(line string, origLine string, index int) readline.CandidateList

func (*Completer) InsertArgs

func (c *Completer) InsertArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) ListFiles

func (c *Completer) ListFiles(path string, includeExt []string, repository string) []string

func (*Completer) PrepareArgs

func (c *Completer) PrepareArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) RemoveFlagArgs

func (c *Completer) RemoveFlagArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) SearchAllTables

func (c *Completer) SearchAllTables(line string, origLine string, index int) readline.CandidateList

func (*Completer) SearchAllTablesWithSpace

func (c *Completer) SearchAllTablesWithSpace(line string, origLine string, index int) readline.CandidateList

func (*Completer) SearchDirs

func (c *Completer) SearchDirs(line string, origLine string, index int) readline.CandidateList

func (*Completer) SearchExecutableFiles

func (c *Completer) SearchExecutableFiles(line string, origLine string, index int) readline.CandidateList

func (*Completer) SearchValues

func (c *Completer) SearchValues(line string, origLine string, index int) readline.CandidateList

func (*Completer) SearchValuesWithSpace

func (c *Completer) SearchValuesWithSpace(line string, origLine string, index int) readline.CandidateList

func (*Completer) SelectArgs

func (c *Completer) SelectArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) SetArgs

func (c *Completer) SetArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) SetLastIndex

func (c *Completer) SetLastIndex(line string)

func (*Completer) ShowArgs

func (c *Completer) ShowArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) Statements

func (c *Completer) Statements(line string, origLine string, index int) readline.CandidateList

func (*Completer) TableObjectArgs

func (c *Completer) TableObjectArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) Update

func (c *Completer) Update()

func (*Completer) UpdateArgs

func (c *Completer) UpdateArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) UpdateTokens

func (c *Completer) UpdateTokens(line string, origLine string)

func (*Completer) UsingArgs

func (c *Completer) UsingArgs(line string, origLine string, index int) readline.CandidateList

func (*Completer) WithArgs

func (c *Completer) WithArgs(line string, origLine string, index int) readline.CandidateList

type ContainsSubstitusion

type ContainsSubstitusion struct{}

func (*ContainsSubstitusion) Error

func (c *ContainsSubstitusion) Error() string

type ContextIsDone

type ContextIsDone struct {
	*BaseError
}

type CumeDist

type CumeDist struct{}

func (CumeDist) CheckArgsLen

func (fn CumeDist) CheckArgsLen(expr parser.AnalyticFunction) error

func (CumeDist) Execute

func (fn CumeDist) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type Cursor

type Cursor struct {
	// contains filtered or unexported fields
}

func NewCursor

func NewCursor(e parser.CursorDeclaration) *Cursor

func NewPseudoCursor

func NewPseudoCursor(tx *Transaction, values []value.Primary) *Cursor

func (*Cursor) Close

func (c *Cursor) Close(name parser.Identifier) error

func (*Cursor) Count

func (c *Cursor) Count() (int, error)

func (*Cursor) Fetch

func (c *Cursor) Fetch(name parser.Identifier, position int, number int) ([]value.Primary, error)

func (*Cursor) IsInRange

func (c *Cursor) IsInRange() (ternary.Value, error)

func (*Cursor) IsOpen

func (c *Cursor) IsOpen() ternary.Value

func (*Cursor) Open

func (c *Cursor) Open(ctx context.Context, filter *Filter, name parser.Identifier, values []parser.ReplaceValue) error

func (*Cursor) Pointer

func (c *Cursor) Pointer() (int, error)

type CursorClosedError

type CursorClosedError struct {
	*BaseError
}

type CursorFetchLengthError

type CursorFetchLengthError struct {
	*BaseError
}

type CursorMap

type CursorMap map[string]*Cursor

func (CursorMap) AddPseudoCursor

func (m CursorMap) AddPseudoCursor(tx *Transaction, name parser.Identifier, values []value.Primary) error

func (CursorMap) Close

func (m CursorMap) Close(name parser.Identifier) error

func (CursorMap) Count

func (m CursorMap) Count(name parser.Identifier) (int, error)

func (CursorMap) Declare

func (m CursorMap) Declare(expr parser.CursorDeclaration) error

func (CursorMap) Dispose

func (m CursorMap) Dispose(name parser.Identifier) error

func (CursorMap) Fetch

func (m CursorMap) Fetch(name parser.Identifier, position int, number int) ([]value.Primary, error)

func (CursorMap) IsInRange

func (m CursorMap) IsInRange(name parser.Identifier) (ternary.Value, error)

func (CursorMap) IsOpen

func (m CursorMap) IsOpen(name parser.Identifier) (ternary.Value, error)

func (CursorMap) Keys

func (m CursorMap) Keys() []string

func (CursorMap) Open

func (m CursorMap) Open(ctx context.Context, filter *Filter, name parser.Identifier, values []parser.ReplaceValue) error

func (CursorMap) SortedKeys

func (m CursorMap) SortedKeys() []string

type CursorOpenError

type CursorOpenError struct {
	*BaseError
}

type CursorRedeclaredError

type CursorRedeclaredError struct {
	*BaseError
}

type CursorScopes

type CursorScopes []CursorMap

func (CursorScopes) AddPseudoCursor

func (list CursorScopes) AddPseudoCursor(tx *Transaction, name parser.Identifier, values []value.Primary) error

func (CursorScopes) All

func (list CursorScopes) All() CursorMap

func (CursorScopes) Close

func (list CursorScopes) Close(name parser.Identifier) error

func (CursorScopes) Count

func (list CursorScopes) Count(name parser.Identifier) (int, error)

func (CursorScopes) Declare

func (list CursorScopes) Declare(expr parser.CursorDeclaration) error

func (CursorScopes) Dispose

func (list CursorScopes) Dispose(name parser.Identifier) error

func (CursorScopes) Fetch

func (list CursorScopes) Fetch(name parser.Identifier, position int, number int) ([]value.Primary, error)

func (CursorScopes) IsInRange

func (list CursorScopes) IsInRange(name parser.Identifier) (ternary.Value, error)

func (CursorScopes) IsOpen

func (list CursorScopes) IsOpen(name parser.Identifier) (ternary.Value, error)

func (CursorScopes) Open

func (list CursorScopes) Open(ctx context.Context, filter *Filter, name parser.Identifier, values []parser.ReplaceValue) error

type DataParsingError

type DataParsingError struct {
	*BaseError
}

type DeleteTableNotSpecifiedError

type DeleteTableNotSpecifiedError struct {
	*BaseError
}

type DenseRank

type DenseRank struct{}

func (DenseRank) CheckArgsLen

func (fn DenseRank) CheckArgsLen(expr parser.AnalyticFunction) error

func (DenseRank) Execute

func (fn DenseRank) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type Direction

type Direction string

const (
	RightDirection Direction = "R"
	LeftDirection            = "L"
)

type Discard

type Discard struct {
}

func NewDiscard

func NewDiscard() *Discard

func (Discard) Close

func (d Discard) Close() error

func (Discard) Write

func (d Discard) Write(p []byte) (int, error)

type DuplicateFieldNameError

type DuplicateFieldNameError struct {
	*BaseError
}

type DuplicateParameterError

type DuplicateParameterError struct {
	*BaseError
}

type DuplicateStatementNameError

type DuplicateStatementNameError struct {
	*BaseError
}

type DuplicateTableNameError

type DuplicateTableNameError struct {
	*BaseError
}

type EmptyJsonQueryError

type EmptyJsonQueryError struct {
	*BaseError
}

type EmptyJsonTableError

type EmptyJsonTableError struct {
	*BaseError
}

type EmptyResultSetError

type EmptyResultSetError struct{}

func NewEmptyResultSetError

func NewEmptyResultSetError() *EmptyResultSetError

func (EmptyResultSetError) Error

func (e EmptyResultSetError) Error() string

type Error

type Error interface {
	Error() string
	Message() string
	Code() int
	Number() int
	Line() int
	Char() int
	Source() string
	// contains filtered or unexported methods
}

type ExternalCommandError

type ExternalCommandError struct {
	*BaseError
}

type FieldAmbiguousError

type FieldAmbiguousError struct {
	*BaseError
}

type FieldLengthNotMatchError

type FieldLengthNotMatchError struct {
	*BaseError
}

type FieldNotExistError

type FieldNotExistError struct {
	*BaseError
}

type FieldNotGroupKeyError

type FieldNotGroupKeyError struct {
	*BaseError
}

type FileAlreadyExistError

type FileAlreadyExistError struct {
	*BaseError
}

type FileInfo

type FileInfo struct {
	Path string

	Format             cmd.Format
	Delimiter          rune
	DelimiterPositions fixedlen.DelimiterPositions
	JsonQuery          string
	Encoding           text.Encoding
	LineBreak          text.LineBreak
	NoHeader           bool
	EncloseAll         bool
	JsonEscape         json.EscapeType
	PrettyPrint        bool

	SingleLine bool

	Handler *file.Handler

	ForUpdate        bool
	IsTemporary      bool
	InitialHeader    Header
	InitialRecordSet RecordSet
}

func AddColumns

func AddColumns(ctx context.Context, parentFilter *Filter, query parser.AddColumns) (*FileInfo, int, error)

func CreateTable

func CreateTable(ctx context.Context, parentFilter *Filter, query parser.CreateTable) (*FileInfo, error)

func Delete

func Delete(ctx context.Context, parentFilter *Filter, query parser.DeleteQuery) ([]*FileInfo, []int, error)

func DropColumns

func DropColumns(ctx context.Context, parentFilter *Filter, query parser.DropColumns) (*FileInfo, int, error)

func Insert

func Insert(ctx context.Context, parentFilter *Filter, query parser.InsertQuery) (*FileInfo, int, error)

func NewFileInfo

func NewFileInfo(
	filename parser.Identifier,
	repository string,
	format cmd.Format,
	delimiter rune,
	encoding text.Encoding,
	flags *cmd.Flags,
) (*FileInfo, error)

func NewFileInfoForCreate

func NewFileInfoForCreate(filename parser.Identifier, repository string, delimiter rune, encoding text.Encoding) (*FileInfo, error)

func RenameColumn

func RenameColumn(ctx context.Context, parentFilter *Filter, query parser.RenameColumn) (*FileInfo, error)

func SetTableAttribute

func SetTableAttribute(ctx context.Context, parentFilter *Filter, query parser.SetTableAttribute) (*FileInfo, string, error)

func Update

func Update(ctx context.Context, parentFilter *Filter, query parser.UpdateQuery) ([]*FileInfo, []int, error)

func (*FileInfo) SetDelimiter

func (f *FileInfo) SetDelimiter(s string) error

func (*FileInfo) SetDelimiterPositions

func (f *FileInfo) SetDelimiterPositions(s string) error

func (*FileInfo) SetEncloseAll

func (f *FileInfo) SetEncloseAll(b bool) error

func (*FileInfo) SetEncoding

func (f *FileInfo) SetEncoding(s string) error

func (*FileInfo) SetFormat

func (f *FileInfo) SetFormat(s string) error

func (*FileInfo) SetJsonEscape

func (f *FileInfo) SetJsonEscape(s string) error

func (*FileInfo) SetLineBreak

func (f *FileInfo) SetLineBreak(s string) error

func (*FileInfo) SetNoHeader

func (f *FileInfo) SetNoHeader(b bool) error

func (*FileInfo) SetPrettyPrint

func (f *FileInfo) SetPrettyPrint(b bool) error

type FileLockTimeoutError

type FileLockTimeoutError struct {
	*BaseError
}

type FileNameAmbiguousError

type FileNameAmbiguousError struct {
	*BaseError
}

type FileNotExistError

type FileNotExistError struct {
	*BaseError
}

type FileUnableToReadError

type FileUnableToReadError struct {
	*BaseError
}

type Filter

type Filter struct {
	// contains filtered or unexported fields
}

func NewFilter

func NewFilter(tx *Transaction) *Filter

func NewFilterForRecord

func NewFilterForRecord(parentFilter *Filter, view *View, recordIndex int) *Filter

func NewFilterForSequentialEvaluation

func NewFilterForSequentialEvaluation(parentFilter *Filter, view *View) *Filter

func NewFilterWithScopes

func NewFilterWithScopes(tx *Transaction, variableScopes VariableScopes, tempViewScopes TemporaryViewScopes, cursorScopes CursorScopes, functionScopes UserDefinedFunctionScopes) *Filter

func (*Filter) CreateChildScope

func (f *Filter) CreateChildScope() *Filter

func (*Filter) CreateNode

func (f *Filter) CreateNode() *Filter

func (*Filter) Evaluate

func (f *Filter) Evaluate(ctx context.Context, expr parser.QueryExpression) (value.Primary, error)

func (*Filter) EvaluateEmbeddedString

func (f *Filter) EvaluateEmbeddedString(ctx context.Context, embedded string) (string, error)

func (*Filter) EvaluateSequentially

func (f *Filter) EvaluateSequentially(ctx context.Context, fn func(*Filter, int) error) error

func (*Filter) LoadInlineTable

func (f *Filter) LoadInlineTable(ctx context.Context, clause parser.WithClause) error

func (*Filter) Merge

func (f *Filter) Merge(filter *Filter)

func (*Filter) ResetCurrentScope

func (f *Filter) ResetCurrentScope()

type FirstValue

type FirstValue struct{}

func (FirstValue) CheckArgsLen

func (fn FirstValue) CheckArgsLen(expr parser.AnalyticFunction) error

func (FirstValue) Execute

func (fn FirstValue) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type FlagValueNotAllowedFormatError

type FlagValueNotAllowedFormatError struct {
	*BaseError
}

type ForcedExit

type ForcedExit struct {
	*BaseError
}

type FormatStringLengthNotMatchError

type FormatStringLengthNotMatchError struct {
	*BaseError
}

type FormatUnexpectedTerminationError

type FormatUnexpectedTerminationError struct {
	*BaseError
}

type FunctionArgumentLengthError

type FunctionArgumentLengthError struct {
	*BaseError
}

type FunctionInvalidArgumentError

type FunctionInvalidArgumentError struct {
	*BaseError
}

type FunctionNotExistError

type FunctionNotExistError struct {
	*BaseError
}

type FunctionRedeclaredError

type FunctionRedeclaredError struct {
	*BaseError
}

type GoroutineManager

type GoroutineManager struct {
	Count                  int
	CountMutex             *sync.Mutex
	MinimumRequiredPerCore int
}

func GetGoroutineManager

func GetGoroutineManager() *GoroutineManager

func (*GoroutineManager) AssignRoutineNumber

func (m *GoroutineManager) AssignRoutineNumber(recordLen int, minimumRequiredPerCore int, cpuNum int) int

func (*GoroutineManager) Release

func (m *GoroutineManager) Release()

type GoroutineTaskManager

type GoroutineTaskManager struct {
	Number int
	// contains filtered or unexported fields
}

func NewGoroutineTaskManager

func NewGoroutineTaskManager(recordLen int, minimumRequiredPerCore int, cpuNum int) *GoroutineTaskManager

func (*GoroutineTaskManager) Add

func (m *GoroutineTaskManager) Add()

func (*GoroutineTaskManager) Done

func (m *GoroutineTaskManager) Done()

func (*GoroutineTaskManager) Err

func (m *GoroutineTaskManager) Err() error

func (*GoroutineTaskManager) HasError

func (m *GoroutineTaskManager) HasError() bool

func (*GoroutineTaskManager) RecordRange

func (m *GoroutineTaskManager) RecordRange(routineIndex int) (int, int)

func (*GoroutineTaskManager) Run

func (m *GoroutineTaskManager) Run(ctx context.Context, fn func(int) error) error

func (*GoroutineTaskManager) SetError

func (m *GoroutineTaskManager) SetError(e error)

func (*GoroutineTaskManager) Wait

func (m *GoroutineTaskManager) Wait()

type Header

type Header []HeaderField

func AddHeaderField

func AddHeaderField(h Header, column string, alias string) (header Header, index int)

func MergeHeader

func MergeHeader(h1 Header, h2 Header) Header

func NewDualHeader

func NewDualHeader() Header

func NewEmptyHeader

func NewEmptyHeader(len int) Header

func NewHeader

func NewHeader(view string, words []string) Header

func NewHeaderWithAutofill

func NewHeaderWithAutofill(view string, words []string) Header

func NewHeaderWithId

func NewHeaderWithId(view string, words []string) Header

func (Header) Contains

func (h Header) Contains(fieldRef parser.FieldReference) (int, error)

func (Header) ContainsInternalId

func (h Header) ContainsInternalId(viewName string) (int, error)

func (Header) ContainsNumber

func (h Header) ContainsNumber(number parser.ColumnNumber) (int, error)

func (Header) ContainsObject

func (h Header) ContainsObject(obj parser.QueryExpression) (int, error)

func (Header) Copy

func (h Header) Copy() Header

func (Header) Len

func (h Header) Len() int

func (Header) TableColumnNames

func (h Header) TableColumnNames() []string

func (Header) TableColumns

func (h Header) TableColumns() []parser.QueryExpression

func (Header) Update

func (h Header) Update(reference string, fields []parser.QueryExpression) error

type HeaderField

type HeaderField struct {
	View         string
	Column       string
	Aliases      []string
	Number       int
	IsFromTable  bool
	IsJoinColumn bool
	IsGroupKey   bool
}

type IOError

type IOError struct {
	*BaseError
}

type InLineTableRedefinedError

type InLineTableRedefinedError struct {
	*BaseError
}

type IncorrectCommandUsageError

type IncorrectCommandUsageError struct {
	*BaseError
}

type InlineTableFieldLengthError

type InlineTableFieldLengthError struct {
	*BaseError
}

type InlineTableMap

type InlineTableMap map[string]*View

func (InlineTableMap) Get

func (it InlineTableMap) Get(name parser.Identifier) (*View, error)

func (InlineTableMap) Set

func (it InlineTableMap) Set(ctx context.Context, parentFilter *Filter, inlineTable parser.InlineTable) error

type InlineTableNodes

type InlineTableNodes []InlineTableMap

func (InlineTableNodes) Get

func (list InlineTableNodes) Get(name parser.Identifier) (*View, error)

func (InlineTableNodes) Load

func (list InlineTableNodes) Load(ctx context.Context, parentFilter *Filter, clause parser.WithClause) error

func (InlineTableNodes) Set

func (list InlineTableNodes) Set(ctx context.Context, parentFilter *Filter, inlineTable parser.InlineTable) error

type Input

type Input struct {
	// contains filtered or unexported fields
}

func NewInput

func NewInput(r io.Reader) *Input

func (*Input) Close

func (r *Input) Close() error

func (*Input) Read

func (r *Input) Read(p []byte) (int, error)

type InsertRowValueLengthError

type InsertRowValueLengthError struct {
	*BaseError
}

type InsertSelectFieldLengthError

type InsertSelectFieldLengthError struct {
	*BaseError
}

type InternalRecordIdEmptyError

type InternalRecordIdEmptyError struct {
	*BaseError
}

type InternalRecordIdNotExistError

type InternalRecordIdNotExistError struct {
	*BaseError
}

type InvalidCursorStatementError

type InvalidCursorStatementError struct {
	*BaseError
}

type InvalidEventNameError

type InvalidEventNameError struct {
	*BaseError
}

type InvalidFetchPositionError

type InvalidFetchPositionError struct {
	*BaseError
}

type InvalidFlagNameError

type InvalidFlagNameError struct {
	*BaseError
}

type InvalidFlagValueError

type InvalidFlagValueError struct {
	*BaseError
}

type InvalidFlagValueToBeRemoveError

type InvalidFlagValueToBeRemoveError struct {
	*BaseError
}

type InvalidLimitNumberError

type InvalidLimitNumberError struct {
	*BaseError
}

type InvalidLimitPercentageError

type InvalidLimitPercentageError struct {
	*BaseError
}

type InvalidOffsetNumberError

type InvalidOffsetNumberError struct {
	*BaseError
}

type InvalidPathError

type InvalidPathError struct {
	*BaseError
}

type InvalidReloadTypeError

type InvalidReloadTypeError struct {
	*BaseError
}

type InvalidRuntimeInformationError

type InvalidRuntimeInformationError struct {
	*BaseError
}

type InvalidTableAttributeNameError

type InvalidTableAttributeNameError struct {
	*BaseError
}

type InvalidTableAttributeValueError

type InvalidTableAttributeValueError struct {
	*BaseError
}

type InvalidTableObjectError

type InvalidTableObjectError struct {
	*BaseError
}

type InvalidValueExpressionError

type InvalidValueExpressionError struct {
	*BaseError
}

type JsonQueryTooManyRecordsError

type JsonQueryTooManyRecordsError struct {
	*BaseError
}

type Lag

type Lag struct{}

func (Lag) CheckArgsLen

func (fn Lag) CheckArgsLen(expr parser.AnalyticFunction) error

func (Lag) Execute

func (fn Lag) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type LastValue

type LastValue struct{}

func (LastValue) CheckArgsLen

func (fn LastValue) CheckArgsLen(expr parser.AnalyticFunction) error

func (LastValue) Execute

func (fn LastValue) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type Lead

type Lead struct{}

func (Lead) CheckArgsLen

func (fn Lead) CheckArgsLen(expr parser.AnalyticFunction) error

func (Lead) Execute

func (fn Lead) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type LoadConfigurationError

type LoadConfigurationError struct {
	*BaseError
}

type LoadJsonError

type LoadJsonError struct {
	*BaseError
}

type NTile

type NTile struct{}

func (NTile) CheckArgsLen

func (fn NTile) CheckArgsLen(expr parser.AnalyticFunction) error

func (NTile) Execute

func (fn NTile) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type NestedAggregateFunctionsError

type NestedAggregateFunctionsError struct {
	*BaseError
}

type NotGroupingRecordsError

type NotGroupingRecordsError struct {
	*BaseError
}

type NotTableError

type NotTableError struct {
	*BaseError
}

type NthValue

type NthValue struct{}

func (NthValue) CheckArgsLen

func (fn NthValue) CheckArgsLen(expr parser.AnalyticFunction) error

func (NthValue) Execute

func (fn NthValue) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type ObjectStatus

type ObjectStatus int

const (
	ObjectFixed ObjectStatus = iota
	ObjectCreated
	ObjectUpdated
)

type ObjectWriter

type ObjectWriter struct {
	Flags   *cmd.Flags
	Palette *color.Palette

	MaxWidth    int
	Padding     int
	Indent      int
	IndentWidth int

	Title1       string
	Title1Effect string
	Title2       string
	Title2Effect string
	// contains filtered or unexported fields
}

func NewObjectWriter

func NewObjectWriter(tx *Transaction) *ObjectWriter

func (*ObjectWriter) BeginBlock

func (w *ObjectWriter) BeginBlock()

func (*ObjectWriter) BeginSubBlock

func (w *ObjectWriter) BeginSubBlock()

func (*ObjectWriter) Clear

func (w *ObjectWriter) Clear()

func (*ObjectWriter) ClearBlock

func (w *ObjectWriter) ClearBlock()

func (*ObjectWriter) EndBlock

func (w *ObjectWriter) EndBlock()

func (*ObjectWriter) EndSubBlock

func (w *ObjectWriter) EndSubBlock()

func (*ObjectWriter) FitInLine

func (w *ObjectWriter) FitInLine(s string) bool

func (*ObjectWriter) NewLine

func (w *ObjectWriter) NewLine()

func (*ObjectWriter) String

func (w *ObjectWriter) String() string

func (*ObjectWriter) Write

func (w *ObjectWriter) Write(s string)

func (*ObjectWriter) WriteColor

func (w *ObjectWriter) WriteColor(s string, effect string)

func (*ObjectWriter) WriteColorWithoutLineBreak

func (w *ObjectWriter) WriteColorWithoutLineBreak(s string, effect string)

func (*ObjectWriter) WriteSpaces

func (w *ObjectWriter) WriteSpaces(l int)

func (*ObjectWriter) WriteWithAutoLineBreak

func (w *ObjectWriter) WriteWithAutoLineBreak(s string)

func (*ObjectWriter) WriteWithoutLineBreak

func (w *ObjectWriter) WriteWithoutLineBreak(s string)

type Output

type Output struct {
	*bytes.Buffer
}

func NewOutput

func NewOutput() *Output

func (*Output) Close

func (w *Output) Close() error

type PaddingType

type PaddingType string

const (
	PaddingRuneCount PaddingType = "LEN"
	PaddingByteCount PaddingType = "BYTE"
	PaddingWidth     PaddingType = "WIDTH"
)

type Partition

type Partition []int

func (Partition) Reverse

func (p Partition) Reverse()

type Partitions

type Partitions map[string]Partition

type PercentRank

type PercentRank struct{}

func (PercentRank) CheckArgsLen

func (fn PercentRank) CheckArgsLen(expr parser.AnalyticFunction) error

func (PercentRank) Execute

func (fn PercentRank) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type PreparedStatement

type PreparedStatement struct {
	Name            string
	StatementString string
	Statements      []parser.Statement
	HolderNumber    int
}

func NewPreparedStatement

func NewPreparedStatement(filter *Filter, expr parser.StatementPreparation) (*PreparedStatement, error)

type PreparedStatementMap

type PreparedStatementMap struct {
	*SyncMap
}

func NewPreparedStatementMap

func NewPreparedStatementMap() PreparedStatementMap

func (PreparedStatementMap) Delete

func (m PreparedStatementMap) Delete(name string)

func (PreparedStatementMap) Dispose

func (m PreparedStatementMap) Dispose(expr parser.DisposeStatement) error

func (PreparedStatementMap) Exists

func (m PreparedStatementMap) Exists(name string) bool

func (PreparedStatementMap) Get

func (m PreparedStatementMap) Get(name parser.Identifier) (*PreparedStatement, error)

func (PreparedStatementMap) Load

func (m PreparedStatementMap) Load(name string) (*PreparedStatement, bool)

func (PreparedStatementMap) Prepare

func (m PreparedStatementMap) Prepare(filter *Filter, expr parser.StatementPreparation) error

func (PreparedStatementMap) Store

func (m PreparedStatementMap) Store(name string, statement *PreparedStatement)

type PreparedStatementSyntaxError

type PreparedStatementSyntaxError struct {
	*BaseError
}

type Processor

type Processor struct {
	Tx     *Transaction
	Filter *Filter
	// contains filtered or unexported fields
}

func NewProcessor

func NewProcessor(tx *Transaction) *Processor

func NewProcessorWithFilter

func NewProcessorWithFilter(tx *Transaction, filter *Filter) *Processor

func (*Processor) AutoCommit

func (proc *Processor) AutoCommit(ctx context.Context) error

func (*Processor) AutoRollback

func (proc *Processor) AutoRollback() error

func (*Processor) Case

func (proc *Processor) Case(ctx context.Context, stmt parser.Case) (StatementFlow, error)

func (*Processor) Commit

func (proc *Processor) Commit(ctx context.Context, expr parser.Expression) error

func (*Processor) ExecExternalCommand

func (proc *Processor) ExecExternalCommand(ctx context.Context, stmt parser.ExternalCommand) error

func (*Processor) Execute

func (proc *Processor) Execute(ctx context.Context, statements []parser.Statement) (StatementFlow, error)

func (*Processor) ExecuteStatement

func (proc *Processor) ExecuteStatement(ctx context.Context, stmt parser.Statement) (StatementFlow, error)

func (*Processor) IfStmt

func (proc *Processor) IfStmt(ctx context.Context, stmt parser.If) (StatementFlow, error)

func (*Processor) Log

func (proc *Processor) Log(log string, quiet bool)

func (*Processor) LogError

func (proc *Processor) LogError(log string)

func (*Processor) LogNotice

func (proc *Processor) LogNotice(log string, quiet bool)

func (*Processor) LogWarn

func (proc *Processor) LogWarn(log string, quiet bool)

func (*Processor) NewChildProcessor

func (proc *Processor) NewChildProcessor() *Processor

func (*Processor) ReleaseResources

func (proc *Processor) ReleaseResources() error

func (*Processor) ReleaseResourcesWithErrors

func (proc *Processor) ReleaseResourcesWithErrors() error

func (*Processor) Rollback

func (proc *Processor) Rollback(expr parser.Expression) error

func (*Processor) While

func (proc *Processor) While(ctx context.Context, stmt parser.While) (StatementFlow, error)

func (*Processor) WhileInCursor

func (proc *Processor) WhileInCursor(ctx context.Context, stmt parser.WhileInCursor) (StatementFlow, error)

type Prompt

type Prompt struct {
	// contains filtered or unexported fields
}

func NewPrompt

func NewPrompt(filter *Filter, palette *color.Palette) *Prompt

func (*Prompt) LoadConfig

func (p *Prompt) LoadConfig() error

func (*Prompt) Render

func (p *Prompt) Render(ctx context.Context, sequence []PromptElement) (string, error)

func (*Prompt) RenderContinuousPrompt

func (p *Prompt) RenderContinuousPrompt(ctx context.Context) (string, error)

func (*Prompt) RenderPrompt

func (p *Prompt) RenderPrompt(ctx context.Context) (string, error)

func (*Prompt) StripEscapeSequence

func (p *Prompt) StripEscapeSequence(s string) string

type PromptElement

type PromptElement struct {
	Text string
	Type excmd.ElementType
}

type PromptEvaluationError

type PromptEvaluationError struct {
	Message string
}

func (PromptEvaluationError) Error

func (e PromptEvaluationError) Error() string

type PseudoCursorError

type PseudoCursorError struct {
	*BaseError
}

type Rank

type Rank struct{}

func (Rank) CheckArgsLen

func (fn Rank) CheckArgsLen(expr parser.AnalyticFunction) error

func (Rank) Execute

func (fn Rank) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type ReadLineTerminal

type ReadLineTerminal struct {
	// contains filtered or unexported fields
}

func (ReadLineTerminal) GetSize

func (t ReadLineTerminal) GetSize() (int, int, error)

func (ReadLineTerminal) ReadLine

func (t ReadLineTerminal) ReadLine() (string, error)

func (ReadLineTerminal) ReloadConfig

func (t ReadLineTerminal) ReloadConfig() error

func (ReadLineTerminal) SaveHistory

func (t ReadLineTerminal) SaveHistory(s string) error

func (ReadLineTerminal) SetContinuousPrompt

func (t ReadLineTerminal) SetContinuousPrompt(ctx context.Context)

func (ReadLineTerminal) SetPrompt

func (t ReadLineTerminal) SetPrompt(ctx context.Context)

func (ReadLineTerminal) Teardown

func (t ReadLineTerminal) Teardown() error

func (ReadLineTerminal) UpdateCompleter

func (t ReadLineTerminal) UpdateCompleter()

func (ReadLineTerminal) Write

func (t ReadLineTerminal) Write(s string) error

func (ReadLineTerminal) WriteError

func (t ReadLineTerminal) WriteError(s string) error

type ReadlineListener

type ReadlineListener struct {
	// contains filtered or unexported fields
}

func (ReadlineListener) OnChange

func (l ReadlineListener) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)

type Record

type Record []Cell

func NewEmptyRecord

func NewEmptyRecord(len int) Record

func NewRecord

func NewRecord(values []value.Primary) Record

func NewRecordWithId

func NewRecordWithId(internalId int, values []value.Primary) Record

func (Record) Copy

func (r Record) Copy() Record

func (Record) GroupLen

func (r Record) GroupLen() int

func (Record) SerializeComparisonKeys

func (r Record) SerializeComparisonKeys(buf *bytes.Buffer, flags *cmd.Flags)

type RecordReader

type RecordReader interface {
	Read() ([]text.RawText, error)
}

type RecordSet

type RecordSet []Record

func MergeRecordSetList

func MergeRecordSetList(list []RecordSet) RecordSet

func (RecordSet) Copy

func (r RecordSet) Copy() RecordSet

type RemoveFlagNotSupportedNameError

type RemoveFlagNotSupportedNameError struct {
	*BaseError
}

type ReplaceValueLengthError

type ReplaceValueLengthError struct {
	*BaseError
}

type ReplaceValues

type ReplaceValues struct {
	Values []parser.QueryExpression
	Names  map[string]int
}

func NewReplaceValues

func NewReplaceValues(replace []parser.ReplaceValue) *ReplaceValues

type RollbackError

type RollbackError struct {
	*BaseError
}

type RowNumber

type RowNumber struct{}

func (RowNumber) CheckArgsLen

func (fn RowNumber) CheckArgsLen(expr parser.AnalyticFunction) error

func (RowNumber) Execute

func (fn RowNumber) Execute(ctx context.Context, filter *Filter, partition Partition, expr parser.AnalyticFunction) (map[int]value.Primary, error)

type RowValueLengthInComparisonError

type RowValueLengthInComparisonError struct {
	*BaseError
}

type RowValueLengthInListError

type RowValueLengthInListError struct {
	*BaseError
	Index int
}

type SelectFieldLengthInComparisonError

type SelectFieldLengthInComparisonError struct {
	*BaseError
}

type Session

type Session struct {
	ScreenFd uintptr
	Stdin    io.ReadCloser
	Stdout   io.WriteCloser
	Stderr   io.WriteCloser
	OutFile  io.Writer
	Terminal VirtualTerminal
}

func NewSession

func NewSession() *Session

func (*Session) CanReadStdin

func (sess *Session) CanReadStdin() bool

func (*Session) Log

func (sess *Session) Log(log string, quiet bool)

func (*Session) LogError

func (sess *Session) LogError(log string)

func (*Session) LogNotice

func (sess *Session) LogNotice(log string, quiet bool)

func (*Session) LogWarn

func (sess *Session) LogWarn(log string, quiet bool)

func (*Session) WriteToStderr

func (sess *Session) WriteToStderr(s string) error

func (*Session) WriteToStderrWithLineBreak

func (sess *Session) WriteToStderrWithLineBreak(s string) error

func (*Session) WriteToStdout

func (sess *Session) WriteToStdout(s string) error

func (*Session) WriteToStdoutWithLineBreak

func (sess *Session) WriteToStdoutWithLineBreak(s string) error

type ShowInvalidObjectTypeError

type ShowInvalidObjectTypeError struct {
	*BaseError
}

type SortValue

type SortValue struct {
	Type SortValueType

	Integer  int64
	Float    float64
	Datetime int64
	String   string
	Boolean  bool
}

func NewSortValue

func NewSortValue(val value.Primary, flags *cmd.Flags) *SortValue

func (*SortValue) EquivalentTo

func (v *SortValue) EquivalentTo(compareValue *SortValue) bool

func (*SortValue) Less

func (v *SortValue) Less(compareValue *SortValue) ternary.Value

type SortValueType

type SortValueType int

const (
	NullType SortValueType = iota
	IntegerType
	FloatType
	DatetimeType
	BooleanType
	StringType
)

type SortValues

type SortValues []*SortValue

func (SortValues) EquivalentTo

func (values SortValues) EquivalentTo(compareValues SortValues) bool

func (SortValues) Less

func (values SortValues) Less(compareValues SortValues, directions []int, nullPositions []int) bool

func (SortValues) Serialize

func (values SortValues) Serialize(buf *bytes.Buffer)

type SourceInvalidFilePathError

type SourceInvalidFilePathError struct {
	*BaseError
}

type StatementFlow

type StatementFlow int

const (
	Terminate StatementFlow = iota
	TerminateWithError
	Exit
	Break
	Continue
	Return
)

type StatementNotExistError

type StatementNotExistError struct {
	*BaseError
}

type StatementReplaceValueNotSpecifiedError

type StatementReplaceValueNotSpecifiedError struct {
	*BaseError
}

type StdinEmptyError

type StdinEmptyError struct {
	*BaseError
}

type StringFormatter

type StringFormatter struct {
	// contains filtered or unexported fields
}

func NewStringFormatter

func NewStringFormatter() *StringFormatter

func (*StringFormatter) Format

func (f *StringFormatter) Format(format string, values []value.Primary) (string, error)

type SubqueryTooManyFieldsError

type SubqueryTooManyFieldsError struct {
	*BaseError
}

type SubqueryTooManyRecordsError

type SubqueryTooManyRecordsError struct {
	*BaseError
}

type SyncMap

type SyncMap struct {
	// contains filtered or unexported fields
}

func NewSyncMap

func NewSyncMap() *SyncMap

func (SyncMap) Keys

func (m SyncMap) Keys() []string

func (SyncMap) Len

func (m SyncMap) Len() int

func (SyncMap) Range

func (m SyncMap) Range(fn func(key, value interface{}) bool)

func (SyncMap) SortedKeys

func (m SyncMap) SortedKeys() []string

type SyntaxError

type SyntaxError struct {
	*BaseError
}

type SystemError

type SystemError struct {
	*BaseError
}

type TableAttributeUnchangedError

type TableAttributeUnchangedError struct {
	Path    string
	Message string
}

func (TableAttributeUnchangedError) Error

func (e TableAttributeUnchangedError) Error() string

type TableAttributeValueNotAllowedFormatError

type TableAttributeValueNotAllowedFormatError struct {
	*BaseError
}

type TableFieldLengthError

type TableFieldLengthError struct {
	*BaseError
}

type TableNotLoadedError

type TableNotLoadedError struct {
	*BaseError
}

type TableObjectArgumentsLengthError

type TableObjectArgumentsLengthError struct {
	*BaseError
}

type TableObjectInvalidArgumentError

type TableObjectInvalidArgumentError struct {
	*BaseError
}

type TableObjectInvalidDelimiterError

type TableObjectInvalidDelimiterError struct {
	*BaseError
}

type TableObjectInvalidDelimiterPositionsError

type TableObjectInvalidDelimiterPositionsError struct {
	*BaseError
}

type TableObjectInvalidJsonQueryError

type TableObjectInvalidJsonQueryError struct {
	*BaseError
}

type TableObjectJsonArgumentsLengthError

type TableObjectJsonArgumentsLengthError struct {
	*BaseError
}

type TemporaryTableFieldLengthError

type TemporaryTableFieldLengthError struct {
	*BaseError
}

type TemporaryTableRedeclaredError

type TemporaryTableRedeclaredError struct {
	*BaseError
}

type TemporaryViewScopes

type TemporaryViewScopes []ViewMap

func (TemporaryViewScopes) All

func (list TemporaryViewScopes) All() ViewMap

func (TemporaryViewScopes) Dispose

func (list TemporaryViewScopes) Dispose(name parser.Identifier) error

func (TemporaryViewScopes) Exists

func (list TemporaryViewScopes) Exists(name string) bool

func (TemporaryViewScopes) Get

func (list TemporaryViewScopes) Get(name parser.Identifier) (*View, error)

func (TemporaryViewScopes) GetWithInternalId

func (list TemporaryViewScopes) GetWithInternalId(ctx context.Context, name parser.Identifier, flags *cmd.Flags) (*View, error)

func (TemporaryViewScopes) Replace

func (list TemporaryViewScopes) Replace(view *View)

func (TemporaryViewScopes) Restore

func (list TemporaryViewScopes) Restore(uncomittedViews map[string]*FileInfo) []string

func (TemporaryViewScopes) Set

func (list TemporaryViewScopes) Set(view *View)

func (TemporaryViewScopes) Store

func (list TemporaryViewScopes) Store(uncomittedViews map[string]*FileInfo) []string

type Transaction

type Transaction struct {
	Session *Session

	Environment *cmd.Environment
	Flags       *cmd.Flags

	WaitTimeout   time.Duration
	RetryDelay    time.Duration
	FileContainer *file.Container

	PreparedStatements PreparedStatementMap

	SelectedViews []*View
	AffectedRows  int

	AutoCommit bool
	// contains filtered or unexported fields
}

func NewTransaction

func NewTransaction(ctx context.Context, defaultWaitTimeout time.Duration, retryDelay time.Duration, session *Session) (*Transaction, error)

func (*Transaction) Commit

func (tx *Transaction) Commit(ctx context.Context, filter *Filter, expr parser.Expression) error

func (*Transaction) ReleaseResources

func (tx *Transaction) ReleaseResources() error

func (*Transaction) ReleaseResourcesWithErrors

func (tx *Transaction) ReleaseResourcesWithErrors() error

func (*Transaction) Rollback

func (tx *Transaction) Rollback(filter *Filter, expr parser.Expression) error

func (*Transaction) UpdateWaitTimeout

func (tx *Transaction) UpdateWaitTimeout(waitTimeout float64, retryDelay time.Duration)

type UncommittedViews

type UncommittedViews struct {
	Created map[string]*FileInfo
	Updated map[string]*FileInfo
	// contains filtered or unexported fields
}

func NewUncommittedViews

func NewUncommittedViews() UncommittedViews

func (*UncommittedViews) Clean

func (m *UncommittedViews) Clean()

func (*UncommittedViews) CountCreatedTables

func (m *UncommittedViews) CountCreatedTables() int

func (*UncommittedViews) CountUpdatedTables

func (m *UncommittedViews) CountUpdatedTables() int

func (*UncommittedViews) CountUpdatedViews

func (m *UncommittedViews) CountUpdatedViews() int

func (*UncommittedViews) IsEmpty

func (m *UncommittedViews) IsEmpty() bool

func (*UncommittedViews) SetForCreatedView

func (m *UncommittedViews) SetForCreatedView(fileInfo *FileInfo)

func (*UncommittedViews) SetForUpdatedView

func (m *UncommittedViews) SetForUpdatedView(fileInfo *FileInfo)

func (*UncommittedViews) UncommittedFiles

func (m *UncommittedViews) UncommittedFiles() (map[string]*FileInfo, map[string]*FileInfo)

func (*UncommittedViews) UncommittedTempViews

func (m *UncommittedViews) UncommittedTempViews() map[string]*FileInfo

func (*UncommittedViews) Unset

func (m *UncommittedViews) Unset(fileInfo *FileInfo)

type UndeclaredCursorError

type UndeclaredCursorError struct {
	*BaseError
}

type UndeclaredTemporaryTableError

type UndeclaredTemporaryTableError struct {
	*BaseError
}

type UndeclaredVariableError

type UndeclaredVariableError struct {
	*BaseError
}

type UndefinedInLineTableError

type UndefinedInLineTableError struct {
	*BaseError
}

type UnknownFormatPlaceholderError

type UnknownFormatPlaceholderError struct {
	*BaseError
}

type UnpermittedFunctionStatementError

type UnpermittedFunctionStatementError struct {
	*BaseError
}

type UpdateFieldNotExistError

type UpdateFieldNotExistError struct {
	*BaseError
}

type UpdateValueAmbiguousError

type UpdateValueAmbiguousError struct {
	*BaseError
}

type UserDefinedFunction

type UserDefinedFunction struct {
	Name         parser.Identifier
	Statements   []parser.Statement
	Parameters   []parser.Variable
	Defaults     map[string]parser.QueryExpression
	RequiredArgs int

	IsAggregate bool
	Cursor      parser.Identifier // For Aggregate Functions
}

func (*UserDefinedFunction) CheckArgsLen

func (fn *UserDefinedFunction) CheckArgsLen(expr parser.QueryExpression, name string, argsLen int) error

func (*UserDefinedFunction) Execute

func (fn *UserDefinedFunction) Execute(ctx context.Context, filter *Filter, args []value.Primary) (value.Primary, error)

func (*UserDefinedFunction) ExecuteAggregate

func (fn *UserDefinedFunction) ExecuteAggregate(ctx context.Context, filter *Filter, values []value.Primary, args []value.Primary) (value.Primary, error)

type UserDefinedFunctionMap

type UserDefinedFunctionMap map[string]*UserDefinedFunction

func (UserDefinedFunctionMap) CheckDuplicate

func (m UserDefinedFunctionMap) CheckDuplicate(name parser.Identifier) error

func (UserDefinedFunctionMap) Declare

func (m UserDefinedFunctionMap) Declare(expr parser.FunctionDeclaration) error

func (UserDefinedFunctionMap) DeclareAggregate

func (m UserDefinedFunctionMap) DeclareAggregate(expr parser.AggregateDeclaration) error

func (UserDefinedFunctionMap) Dispose

func (m UserDefinedFunctionMap) Dispose(name parser.Identifier) error

func (UserDefinedFunctionMap) Get

func (m UserDefinedFunctionMap) Get(fn parser.QueryExpression, name string) (*UserDefinedFunction, error)

func (UserDefinedFunctionMap) Keys

func (m UserDefinedFunctionMap) Keys() []string

func (UserDefinedFunctionMap) SortedKeys

func (m UserDefinedFunctionMap) SortedKeys() []string

type UserDefinedFunctionScopes

type UserDefinedFunctionScopes []UserDefinedFunctionMap

func (UserDefinedFunctionScopes) All

func (list UserDefinedFunctionScopes) All() (UserDefinedFunctionMap, UserDefinedFunctionMap)

func (UserDefinedFunctionScopes) Declare

func (list UserDefinedFunctionScopes) Declare(expr parser.FunctionDeclaration) error

func (UserDefinedFunctionScopes) DeclareAggregate

func (list UserDefinedFunctionScopes) DeclareAggregate(expr parser.AggregateDeclaration) error

func (UserDefinedFunctionScopes) Dispose

func (list UserDefinedFunctionScopes) Dispose(name parser.Identifier) error

func (UserDefinedFunctionScopes) Get

func (list UserDefinedFunctionScopes) Get(expr parser.QueryExpression, name string) (*UserDefinedFunction, error)

type UserTriggeredError

type UserTriggeredError struct {
	*BaseError
}

type VariableMap

type VariableMap struct {
	*SyncMap
}

func NewVariableMap

func NewVariableMap() VariableMap

func (VariableMap) Add

func (m VariableMap) Add(variable parser.Variable, value value.Primary) error

func (VariableMap) Declare

func (m VariableMap) Declare(ctx context.Context, filter *Filter, declaration parser.VariableDeclaration) error

func (VariableMap) Delete

func (m VariableMap) Delete(name string)

func (VariableMap) Dispose

func (m VariableMap) Dispose(variable parser.Variable) error

func (VariableMap) Exists

func (m VariableMap) Exists(name string) bool

func (VariableMap) Get

func (m VariableMap) Get(variable parser.Variable) (value.Primary, error)

func (VariableMap) Load

func (m VariableMap) Load(name string) (value.Primary, bool)

func (VariableMap) Set

func (m VariableMap) Set(variable parser.Variable, value value.Primary) error

func (VariableMap) Store

func (m VariableMap) Store(name string, value value.Primary)

func (VariableMap) Substitute

func (m VariableMap) Substitute(ctx context.Context, filter *Filter, substitution parser.VariableSubstitution) (value.Primary, error)

func (VariableMap) SubstituteDirectly

func (m VariableMap) SubstituteDirectly(variable parser.Variable, value value.Primary) (value.Primary, error)

type VariableRedeclaredError

type VariableRedeclaredError struct {
	*BaseError
}

type VariableScopes

type VariableScopes []VariableMap

func (VariableScopes) All

func (list VariableScopes) All() VariableMap

func (VariableScopes) Declare

func (list VariableScopes) Declare(ctx context.Context, filter *Filter, expr parser.VariableDeclaration) error

func (VariableScopes) Dispose

func (list VariableScopes) Dispose(expr parser.Variable) error

func (VariableScopes) Get

func (list VariableScopes) Get(expr parser.Variable) (value value.Primary, err error)

func (VariableScopes) Substitute

func (list VariableScopes) Substitute(ctx context.Context, filter *Filter, expr parser.VariableSubstitution) (value value.Primary, err error)

func (VariableScopes) SubstituteDirectly

func (list VariableScopes) SubstituteDirectly(variable parser.Variable, value value.Primary) (value.Primary, error)

type View

type View struct {
	Header    Header
	RecordSet RecordSet
	FileInfo  *FileInfo

	Tx     *Transaction
	Filter *Filter
	// contains filtered or unexported fields
}

func NewView

func NewView(tx *Transaction) *View

func NewViewFromGroupedRecord

func NewViewFromGroupedRecord(filterRecord filterRecord) *View

func Select

func Select(ctx context.Context, parentFilter *Filter, query parser.SelectQuery) (*View, error)

func (*View) Copy

func (view *View) Copy() *View

func (*View) Except

func (view *View) Except(ctx context.Context, calcView *View, all bool) (err error)

func (*View) ExtendRecordCapacity

func (view *View) ExtendRecordCapacity(ctx context.Context, exprs []parser.QueryExpression) error

func (*View) FieldIndex

func (view *View) FieldIndex(fieldRef parser.QueryExpression) (int, error)

func (*View) FieldIndices

func (view *View) FieldIndices(fields []parser.QueryExpression) ([]int, error)

func (*View) FieldLen

func (view *View) FieldLen() int

func (*View) FieldViewName

func (view *View) FieldViewName(fieldRef parser.QueryExpression) (string, error)

func (*View) Fix

func (view *View) Fix(ctx context.Context) error

func (*View) GenerateComparisonKeys

func (view *View) GenerateComparisonKeys(ctx context.Context) error

func (*View) GroupBy

func (view *View) GroupBy(ctx context.Context, clause parser.GroupByClause) error

func (*View) Having

func (view *View) Having(ctx context.Context, clause parser.HavingClause) error

func (*View) InsertFromQuery

func (view *View) InsertFromQuery(ctx context.Context, fields []parser.QueryExpression, query parser.SelectQuery) (int, error)

func (*View) InsertValues

func (view *View) InsertValues(ctx context.Context, fields []parser.QueryExpression, list []parser.QueryExpression) (int, error)

func (*View) InternalRecordId

func (view *View) InternalRecordId(ref string, recordIndex int) (int, error)

func (*View) Intersect

func (view *View) Intersect(ctx context.Context, calcView *View, all bool) (err error)

func (*View) Len

func (view *View) Len() int

func (*View) Less

func (view *View) Less(i, j int) bool

func (*View) Limit

func (view *View) Limit(ctx context.Context, clause parser.LimitClause) error

func (*View) ListValuesForAggregateFunctions

func (view *View) ListValuesForAggregateFunctions(ctx context.Context, expr parser.QueryExpression, arg parser.QueryExpression, distinct bool, filter *Filter) ([]value.Primary, error)

func (*View) Load

func (view *View) Load(ctx context.Context, filter *Filter, clause parser.FromClause, forUpdate bool, useInternalId bool) error

func (*View) LoadFromTableIdentifier

func (view *View) LoadFromTableIdentifier(ctx context.Context, filter *Filter, table parser.QueryExpression, forUpdate bool, useInternalId bool) error

func (*View) Offset

func (view *View) Offset(ctx context.Context, clause parser.OffsetClause) error

func (*View) OrderBy

func (view *View) OrderBy(ctx context.Context, clause parser.OrderByClause) error

func (*View) RecordLen

func (view *View) RecordLen() int

func (*View) RestoreHeaderReferences

func (view *View) RestoreHeaderReferences() error

func (*View) Select

func (view *View) Select(ctx context.Context, clause parser.SelectClause) error

func (*View) SelectAllColumns

func (view *View) SelectAllColumns(ctx context.Context) error

func (*View) Swap

func (view *View) Swap(i, j int)

func (*View) Union

func (view *View) Union(ctx context.Context, calcView *View, all bool) (err error)

func (*View) Where

func (view *View) Where(ctx context.Context, clause parser.WhereClause) error

type ViewMap

type ViewMap struct {
	*SyncMap
}

func NewViewMap

func NewViewMap() ViewMap

func (ViewMap) Clean

func (m ViewMap) Clean(container *file.Container) error

func (ViewMap) CleanWithErrors

func (m ViewMap) CleanWithErrors(container *file.Container) error

func (ViewMap) Delete

func (m ViewMap) Delete(fpath string)

func (ViewMap) Dispose

func (m ViewMap) Dispose(container *file.Container, name string) error

func (ViewMap) DisposeTemporaryTable

func (m ViewMap) DisposeTemporaryTable(table parser.Identifier) error

func (ViewMap) Exists

func (m ViewMap) Exists(fpath string) bool

func (ViewMap) Get

func (m ViewMap) Get(fpath parser.Identifier) (*View, error)

func (ViewMap) GetWithInternalId

func (m ViewMap) GetWithInternalId(ctx context.Context, fpath parser.Identifier, flags *cmd.Flags) (*View, error)

func (ViewMap) Load

func (m ViewMap) Load(fpath string) (*View, bool)

func (ViewMap) Set

func (m ViewMap) Set(view *View)

func (ViewMap) Store

func (m ViewMap) Store(fpath string, view *View)

type VirtualTerminal

type VirtualTerminal interface {
	ReadLine() (string, error)
	Write(string) error
	WriteError(string) error
	SetPrompt(ctx context.Context)
	SetContinuousPrompt(ctx context.Context)
	SaveHistory(string) error
	Teardown() error
	GetSize() (int, int, error)
	ReloadConfig() error
	UpdateCompleter()
}

func NewTerminal

func NewTerminal(ctx context.Context, filter *Filter) (VirtualTerminal, error)

type WindowFrame

type WindowFrame struct {
	Low     int
	High    int
	Records []int
}

func WindowFrameSet

func WindowFrameSet(partition Partition, expr parser.AnalyticClause) []WindowFrame