_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q20500 | IsEnd | train | func (l *Lexer) IsEnd() bool {
//u.Infof("isEnd? %v:%v", l.pos, len(l.input))
if l.pos >= len(l.input) {
return true
}
// if l.Peek() == ';' {
// return true
// }
return false
} | go | {
"resource": ""
} |
q20501 | IsComment | train | func (l *Lexer) IsComment() bool {
r := l.Peek()
switch r {
case '#':
return true
case '/', '-':
// continue on, might be, check 2nd character
cv := l.PeekX(2)
switch cv {
case "//":
return true
case "--":
return true
}
default:
return false
}
return false
} | go | {
"resource": ""
} |
q20502 | Emit | train | func (l *Lexer) Emit(t TokenType) {
debugf("emit: %s '%s' stack=%v start=%d pos=%d", t, l.input[l.start:l.pos], len(l.stack), l.start, l.pos)
// We are going to use 1 based indexing (not 0 based) for lines
// because humans don't think that way
if l.lastQuoteMark != 0 {
l.lastToken = Token{T: t, V: l.input[l.st... | go | {
"resource": ""
} |
q20503 | ignoreWord | train | func (l *Lexer) ignoreWord(word string) {
l.pos += len(word)
l.start = l.pos
} | go | {
"resource": ""
} |
q20504 | current | train | func (l *Lexer) current() string {
if l.pos <= l.start {
return ""
}
str := l.input[l.start:l.pos]
l.start = l.pos
return str
} | go | {
"resource": ""
} |
q20505 | SkipWhiteSpaces | train | func (l *Lexer) SkipWhiteSpaces() {
for rune := l.Next(); unicode.IsSpace(rune); rune = l.Next() {
if rune == '\n' {
// New line, lets keep track of line position
l.line++
l.linepos = l.pos
}
}
l.backup()
l.ignore()
} | go | {
"resource": ""
} |
q20506 | SkipWhiteSpacesNewLine | train | func (l *Lexer) SkipWhiteSpacesNewLine() bool {
rune := l.Next()
hasNewLine := false
for {
if rune == '\n' {
hasNewLine = true
// New line, lets keep track of line position
l.line++
l.linepos = 0
} else if !unicode.IsSpace(rune) {
break
}
rune = l.Next()
}
l.backup()
l.ignore()
return hasN... | go | {
"resource": ""
} |
q20507 | ReverseTrim | train | func (l *Lexer) ReverseTrim() {
for i := len(l.input) - 1; i >= 0; i-- {
if !unicode.IsSpace(rune(l.input[i])) {
if i < (len(l.input) - 1) {
//u.Warnf("trim: '%v'", l.input[:i+1])
l.input = l.input[:i+1]
}
break
}
}
} | go | {
"resource": ""
} |
q20508 | match | train | func (l *Lexer) match(matchTo string, skip int) bool {
//u.Debugf("match(%q) peek:%q ", matchTo, l.PeekWord())
for _, matchRune := range matchTo {
//u.Debugf("match rune? %v", string(matchRune))
if skip > 0 {
skip--
continue
}
nr := l.Next()
//u.Debugf("rune=%s n=%s %v %v", string(matchRune), st... | go | {
"resource": ""
} |
q20509 | errorToken | train | func (l *Lexer) errorToken(format string, args ...interface{}) StateFn {
//fmt.Sprintf(format, args...)
l.Emit(TokenError)
return nil
} | go | {
"resource": ""
} |
q20510 | isNextKeyword | train | func (l *Lexer) isNextKeyword(peekWord string) bool {
if len(peekWord) == 0 {
return false
}
kwMaybe := strings.ToLower(peekWord)
//u.Debugf("isNextKeyword? '%s' len:%v", kwMaybe, len(l.statement.Clauses))
clause := l.curClause.next
if clause == nil {
clause = l.curClause.parent
}
//u.Infof("clause: %s... | go | {
"resource": ""
} |
q20511 | isIdentity | train | func (l *Lexer) isIdentity() bool {
// Identity are strings not values
r := l.Peek()
switch {
case r == '[':
// This character [ is a little special
// as it is going to look to see if the 2nd character is
// valid identity character so ie alpha/numeric
peek2 := l.PeekX(2)
if len(peek2) == 2 {
return i... | go | {
"resource": ""
} |
q20512 | clauseState | train | func (l *Lexer) clauseState() StateFn {
if l.curClause != nil {
if len(l.curClause.Clauses) > 0 {
return l.curClause.Clauses[0].Lexer
}
return l.curClause.Lexer
}
return emptyLexFn
} | go | {
"resource": ""
} |
q20513 | LexMatchClosure | train | func LexMatchClosure(tok TokenType, nextFn StateFn) StateFn {
return func(l *Lexer) StateFn {
//u.Debugf("%p lexMatch t=%s peek=%s", l, tok, l.PeekWord())
if l.match(tok.String(), 0) {
//u.Debugf("found match: %s %v", tok, nextFn)
l.Emit(tok)
return nextFn
}
u.Warnf("unexpected token: %v peek:%s... | go | {
"resource": ""
} |
q20514 | LexIdentityOrValue | train | func LexIdentityOrValue(l *Lexer) StateFn {
l.SkipWhiteSpaces()
r := l.Peek()
if r == '(' {
return nil
}
//u.Debugf("LexIdentityOrValue identity?%v expr?%v %v peek5='%v'", l.isIdentity(), l.isExpr(), string(l.Peek()), string(l.PeekX(5)))
// Expressions end in Parens: LOWER(item)
if l.isExpr() {
return ... | go | {
"resource": ""
} |
q20515 | LexEndOfStatement | train | func LexEndOfStatement(l *Lexer) StateFn {
l.SkipWhiteSpaces()
r := l.Next()
if r == ';' {
l.Emit(TokenEOS)
return nil
}
l.SkipWhiteSpaces()
if l.IsEnd() {
return nil
}
//u.Warnf("END: %s %s", string(r), l.PeekX(20))
return l.errorToken("Unexpected token:" + l.current())
} | go | {
"resource": ""
} |
q20516 | LexSelectClause | train | func LexSelectClause(l *Lexer) StateFn {
l.SkipWhiteSpaces()
if l.IsEnd() {
return nil
}
if l.Peek() == ')' {
return nil
}
word := strings.ToLower(l.PeekWord())
//u.Debugf("LexSelectClause '%v'", word)
switch word {
case "from", "where", "limit", "group", "having":
return nil
case "all": //ALL?
l.... | go | {
"resource": ""
} |
q20517 | LexUpsertClause | train | func LexUpsertClause(l *Lexer) StateFn {
l.SkipWhiteSpaces()
if l.IsEnd() {
return nil
}
word := strings.ToLower(l.PeekWord())
//u.Debugf("LexUpsertClause '%v' %v", word, l.PeekX(10))
switch word {
case "insert":
l.ConsumeWord(word)
l.Emit(TokenInsert)
return LexUpsertClause
case "upsert":
l.Cons... | go | {
"resource": ""
} |
q20518 | LexSubQuery | train | func LexSubQuery(l *Lexer) StateFn {
//u.Debugf("LexSubQuery '%v'", l.PeekX(10))
l.SkipWhiteSpaces()
r := l.Peek()
if l.IsEnd() {
return nil
}
if r == ')' {
l.Next()
l.Emit(TokenRightParenthesis)
return nil
}
/*
TODO: this is a hack because the LexDialect from above should be recursive,
ie su... | go | {
"resource": ""
} |
q20519 | LexJson | train | func LexJson(l *Lexer) StateFn {
l.SkipWhiteSpaces()
if l.IsEnd() {
return nil
}
r := l.Peek()
//u.Debugf("LexJson '%v' %v", string(r), l.PeekX(10))
switch r {
case '{', '[':
return LexJsonValue
}
//u.Warnf("Did not find json? %v", l.PeekX(20))
return nil
} | go | {
"resource": ""
} |
q20520 | LexJsonArray | train | func LexJsonArray(l *Lexer) StateFn {
l.SkipWhiteSpaces()
if l.IsEnd() {
return nil
}
r := l.Peek()
//u.Debugf("LexJsonArray '%v' peek:%v", string(r), l.PeekX(10))
switch r {
case ']':
l.Next()
l.Emit(TokenRightBracket)
return nil
case ',':
l.Next() // consume ,
l.Emit(TokenComma)
return LexJson... | go | {
"resource": ""
} |
q20521 | LexJsonObject | train | func LexJsonObject(l *Lexer) StateFn {
l.SkipWhiteSpaces()
if l.IsEnd() {
return nil
}
r := l.Peek()
//u.Debugf("LexJsonObject '%v' %v", string(r), l.PeekX(10))
switch r {
case '}':
l.Next()
l.Emit(TokenRightBrace)
return nil
case ':':
l.Next() // consume :
l.Emit(TokenColon)
l.Push("LexJsonObj... | go | {
"resource": ""
} |
q20522 | isAlNumOrPeriod | train | func isAlNumOrPeriod(r rune) bool {
return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r) || r == '.'
} | go | {
"resource": ""
} |
q20523 | isIdentCh | train | func isIdentCh(r rune) bool {
switch {
case isAlNum(r):
return true
case r == '_':
return true
}
return false
} | go | {
"resource": ""
} |
q20524 | IsIdentifierRune | train | func IsIdentifierRune(r rune) bool {
if unicode.IsLetter(r) || unicode.IsDigit(r) {
return true
}
for _, allowedRune := range IDENTITY_CHARS {
if allowedRune == r {
return true
}
}
return false
} | go | {
"resource": ""
} |
q20525 | IsValidIdentity | train | func IsValidIdentity(identity string) bool {
for _, r := range identity {
if !isIdentifierFirstRune(r) {
return false
}
break
}
return IdentityRunesOnly(identity)
} | go | {
"resource": ""
} |
q20526 | NewGroupByFinal | train | func NewGroupByFinal(ctx *plan.Context, p *plan.GroupBy) *GroupByFinal {
m := &GroupByFinal{
TaskBase: NewTaskBase(ctx),
p: p,
complete: make(chan bool),
}
return m
} | go | {
"resource": ""
} |
q20527 | Close | train | func (m *GroupBy) Close() error {
m.Lock()
if m.closed {
m.Unlock()
return nil
}
m.closed = true
m.Unlock()
return m.TaskBase.Close()
} | go | {
"resource": ""
} |
q20528 | Close | train | func (m *GroupByFinal) Close() error {
m.Lock()
if m.closed {
m.Unlock()
return nil
}
m.closed = true
m.Unlock()
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
//u.Infof("%p group by final Close() waiting for complete", m)
select {
case <-ticker.C:
u.Warnf("timeout???? ")
case <-m.com... | go | {
"resource": ""
} |
q20529 | RegisterFileHandler | train | func RegisterFileHandler(scannerType string, fh FileHandler) {
if fh == nil {
panic("File scanners must not be nil")
}
scannerType = strings.ToLower(scannerType)
// u.Debugf("global FileHandler register: %v %T FileHandler:%p", scannerType, fh, fh)
registryMu.Lock()
defer registryMu.Unlock()
if _, dupe := scann... | go | {
"resource": ""
} |
q20530 | findValue | train | func findValue(v reflect.Value) (reflect.Value, bool) {
for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
if v.IsNil() {
return v, true
}
if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
break
}
}
return v, false
} | go | {
"resource": ""
} |
q20531 | NewProjectionFinal | train | func NewProjectionFinal(ctx *Context, p *Select) (*Projection, error) {
s := &Projection{
P: p,
Stmt: p.Stmt,
PlanBase: NewPlanBase(false),
Final: true,
}
var err error
if len(p.Stmt.From) == 0 {
err = s.loadLiteralProjection(ctx)
} else if len(p.From) == 1 && p.From[0].Proj != nil {
s.Pr... | go | {
"resource": ""
} |
q20532 | EmptyEvalFunc | train | func EmptyEvalFunc(ctx EvalContext, args []value.Value) (value.Value, bool) {
return value.NilValueVal, false
} | go | {
"resource": ""
} |
q20533 | NewFuncRegistry | train | func NewFuncRegistry() *FuncRegistry {
return &FuncRegistry{
funcs: make(map[string]Func),
aggs: make(map[string]struct{}),
}
} | go | {
"resource": ""
} |
q20534 | FuncGet | train | func (m *FuncRegistry) FuncGet(name string) (Func, bool) {
m.mu.RLock()
fn, ok := m.funcs[name]
m.mu.RUnlock()
return fn, ok
} | go | {
"resource": ""
} |
q20535 | Validate | train | func (m *ArraySlice) Validate(n *expr.FuncNode) (expr.EvaluatorFunc, error) {
if len(n.Args) < 2 || len(n.Args) > 3 {
return nil, fmt.Errorf("Expected 2 OR 3 args for ArraySlice(array, start, [end]) but got %s", n)
}
return arraySliceEval, nil
} | go | {
"resource": ""
} |
q20536 | EvalFilterSelect | train | func EvalFilterSelect(sel *rel.FilterSelect, writeContext expr.ContextWriter, readContext expr.EvalContext) (bool, bool) {
ctx, ok := readContext.(expr.EvalIncludeContext)
if !ok {
ctx = &expr.IncludeContext{ContextReader: readContext}
}
// Check and see if we are where Guarded, which would discard the entire me... | go | {
"resource": ""
} |
q20537 | MatchesExpr | train | func MatchesExpr(cr expr.EvalContext, node expr.Node) (bool, bool) {
return matchesExpr(cr, node, 0)
} | go | {
"resource": ""
} |
q20538 | DayBucket | train | func DayBucket(dt time.Time) int {
return int(dt.UnixNano() / int64(24*time.Hour))
} | go | {
"resource": ""
} |
q20539 | walkExpr | train | func (fg *FilterGenerator) walkExpr(node expr.Node, depth int) (interface{}, error) {
if depth > MaxDepth {
return nil, fmt.Errorf("hit max depth on segment generation. bad query?")
}
//u.Debugf("%d fg.expr T:%T %#v", depth, node, node)
var err error
var filter interface{}
switch n := node.(type) {
case *expr... | go | {
"resource": ""
} |
q20540 | Values | train | func (m *FileInfo) Values() []driver.Value {
cols := []driver.Value{
m.Name,
m.Table,
m.Path,
m.PartialPath,
m.Size,
m.Partition,
m.updated(),
false,
m.FileType,
}
cols = append(cols, m.AppendCols...)
return cols
} | go | {
"resource": ""
} |
q20541 | FileInfoFromCloudObject | train | func FileInfoFromCloudObject(path string, obj cloudstorage.Object) *FileInfo {
fi := &FileInfo{Name: obj.Name(), obj: obj, Path: path}
fi.Table = TableFromFileAndPath(path, obj.Name())
// Get the part of path as follows
// /path/partialpath/filename.csv
partialPath := strings.Replace(fi.Name, path, "", 1)
par... | go | {
"resource": ""
} |
q20542 | NewCommand | train | func NewCommand(ctx *plan.Context, p *plan.Command) *Command {
m := &Command{
TaskBase: NewTaskBase(ctx),
p: p,
}
return m
} | go | {
"resource": ""
} |
q20543 | FuncResolver | train | func (f *FilterQLParser) FuncResolver(funcs expr.FuncResolver) *FilterQLParser {
f.funcs = funcs
return f
} | go | {
"resource": ""
} |
q20544 | ParseFilters | train | func ParseFilters(statement string) (stmts []*FilterStatement, err error) {
return NewFilterParser(statement).ParseFilters()
} | go | {
"resource": ""
} |
q20545 | parseFilter | train | func (m *FilterQLParser) parseFilter() (*FilterStatement, error) {
req := NewFilterStatement()
m.fs = req
req.Description = m.comment
req.Raw = m.l.RawInput()
m.Next() // Consume (FILTER | WHERE )
// one top level filter which may be nested
filter, err := m.parseFirstFilters()
if err != nil {
return nil, er... | go | {
"resource": ""
} |
q20546 | NewDateConverter | train | func NewDateConverter(ctx expr.EvalIncludeContext, n expr.Node) (*DateConverter, error) {
dc := &DateConverter{
Node: n,
at: time.Now(),
ctx: ctx,
}
dc.findDateMath(n)
if dc.err == nil && len(dc.TimeStrings) > 0 {
dc.HasDateMath = true
}
if dc.err != nil {
return nil, dc.err
}
return dc, nil
} | go | {
"resource": ""
} |
q20547 | booleanExpr | train | func (fg *FilterGenerator) booleanExpr(bn *expr.BooleanNode, depth int) (interface{}, error) {
if depth > MaxDepth {
return nil, fmt.Errorf("hit max depth on segment generation. bad query?")
}
and := true
switch bn.Operator.T {
case lex.TokenAnd, lex.TokenLogicAnd:
case lex.TokenOr, lex.TokenLogicOr:
and = fa... | go | {
"resource": ""
} |
q20548 | Next | train | func (m *LexTokenPager) Next() lex.Token {
m.lexNext()
m.cursor++
if m.cursor+1 > len(m.tokens) {
//u.Warnf("Next() CRAP? increment cursor: %v of %v %v", m.cursor, len(m.tokens))
return eoft
}
return m.tokens[m.cursor-1]
} | go | {
"resource": ""
} |
q20549 | Cur | train | func (m *LexTokenPager) Cur() lex.Token {
if m.cursor+1 > len(m.tokens) {
//u.Warnf("Next() CRAP? increment cursor: %v of %v %v", m.cursor, len(m.tokens), m.cursor < len(m.tokens))
return eoft
}
return m.tokens[m.cursor]
} | go | {
"resource": ""
} |
q20550 | Peek | train | func (m *LexTokenPager) Peek() lex.Token {
if len(m.tokens) <= m.cursor+1 && !m.done {
m.lexNext()
}
if len(m.tokens) < 2 {
m.lexNext()
}
if len(m.tokens) == m.cursor+1 {
return m.tokens[m.cursor]
}
if m.cursor == -1 {
return m.tokens[1]
}
return m.tokens[m.cursor+1]
} | go | {
"resource": ""
} |
q20551 | expect | train | func (t *tree) expect(expected lex.TokenType, context string) lex.Token {
token := t.Cur()
if token.T != expected {
t.unexpected(token, context)
}
return token
} | go | {
"resource": ""
} |
q20552 | parse | train | func (t *tree) parse() (_ Node, err error) {
defer func() {
if p := recover(); p != nil {
err = fmt.Errorf("parse error: %v", p)
}
}()
return t.O(0), err
} | go | {
"resource": ""
} |
q20553 | getFunction | train | func (t *tree) getFunction(name string) (fn Func, ok bool) {
if t.fr != nil {
if fn, ok = t.fr.FuncGet(name); ok {
return
}
}
if fn, ok = funcReg.FuncGet(strings.ToLower(name)); ok {
return
}
return
} | go | {
"resource": ""
} |
q20554 | NewJsonSource | train | func NewJsonSource(table string, rc io.ReadCloser, exit <-chan bool, lh FileLineHandler) (*JsonSource, error) {
js := &JsonSource{
table: table,
exit: exit,
rc: rc,
lhSpec: lh,
lh: lh,
}
buf := bufio.NewReader(rc)
first2, err := buf.Peek(2)
if err != nil {
u.Warnf("error opening bufio.peek... | go | {
"resource": ""
} |
q20555 | NewCreate | train | func NewCreate(ctx *plan.Context, p *plan.Create) *Create {
m := &Create{
TaskBase: NewTaskBase(ctx),
p: p,
}
return m
} | go | {
"resource": ""
} |
q20556 | NewDrop | train | func NewDrop(ctx *plan.Context, p *plan.Drop) *Drop {
m := &Drop{
TaskBase: NewTaskBase(ctx),
p: p,
}
return m
} | go | {
"resource": ""
} |
q20557 | NewAlter | train | func NewAlter(ctx *plan.Context, p *plan.Alter) *Alter {
m := &Alter{
TaskBase: NewTaskBase(ctx),
p: p,
}
return m
} | go | {
"resource": ""
} |
q20558 | NewStaticDataValue | train | func NewStaticDataValue(name string, data interface{}) *StaticDataSource {
row := []driver.Value{data}
ds := NewStaticDataSource(name, 0, [][]driver.Value{row}, []string{name})
return ds
} | go | {
"resource": ""
} |
q20559 | NewDialectWriter | train | func NewDialectWriter(l, i byte) DialectWriter {
return &defaultDialect{LiteralQuote: l, IdentityQuote: i}
} | go | {
"resource": ""
} |
q20560 | WriteLiteral | train | func (w *defaultDialect) WriteLiteral(l string) {
if len(l) == 1 && l == "*" {
w.WriteByte('*')
return
}
LiteralQuoteEscapeBuf(&w.Buffer, rune(w.LiteralQuote), l)
} | go | {
"resource": ""
} |
q20561 | WriteIdentity | train | func (w *defaultDialect) WriteIdentity(i string) {
if len(i) == 1 && i == "*" {
w.WriteByte('*')
return
}
IdentityMaybeEscapeBuf(&w.Buffer, w.IdentityQuote, i)
} | go | {
"resource": ""
} |
q20562 | WriteLeftRightIdentity | train | func (w *defaultDialect) WriteLeftRightIdentity(l, r string) {
if l == "" {
w.WriteIdentity(r)
return
}
// `user`.`email` type namespacing, may need to be escaped differently
if w.stripNamespace {
w.WriteIdentity(r)
return
}
w.WriteIdentity(l)
w.Write([]byte{'.'})
w.WriteIdentity(r)
return
} | go | {
"resource": ""
} |
q20563 | WriteIdentityQuote | train | func (w *defaultDialect) WriteIdentityQuote(i string, quote byte) {
if len(i) == 1 && i == "*" {
w.WriteByte('*')
return
}
LiteralQuoteEscapeBuf(&w.Buffer, rune(w.IdentityQuote), i)
} | go | {
"resource": ""
} |
q20564 | WriteLiteral | train | func (w *jsonDialect) WriteLiteral(l string) {
if len(l) == 1 && l == "*" {
w.WriteByte('*')
return
}
w.Buffer.WriteString(strconv.Quote(l))
} | go | {
"resource": ""
} |
q20565 | NewWhere | train | func NewWhere(ctx *plan.Context, p *plan.Where) *Where {
if p.Final {
return NewWhereFinal(ctx, p)
}
return NewWhereFilter(ctx, p.Stmt)
} | go | {
"resource": ""
} |
q20566 | NewWhereFilter | train | func NewWhereFilter(ctx *plan.Context, sql *rel.SqlSelect) *Where {
s := &Where{
TaskBase: NewTaskBase(ctx),
filter: sql.Where.Expr,
}
cols := sql.ColIndexes()
s.Handler = whereFilter(s.filter, s, cols)
return s
} | go | {
"resource": ""
} |
q20567 | Cast | train | func Cast(valType ValueType, val Value) (Value, error) {
switch valType {
case ByteSliceType:
switch valt := val.(type) {
case ByteSliceValue:
return valt, nil
default:
return NewByteSliceValue([]byte(val.ToString())), nil
}
case TimeType:
t, ok := ValueToTime(val)
if ok {
return NewTimeValue(t... | go | {
"resource": ""
} |
q20568 | Equal | train | func Equal(l, r Value) (bool, error) {
if l == nil && r == nil {
return true, nil
}
if r == nil {
switch l.(type) {
case NilValue:
return true, nil
}
return false, nil
}
if _, isNil := r.(NilValue); isNil {
switch l.(type) {
case nil:
return true, nil
case NilValue:
return true, nil
}
... | go | {
"resource": ""
} |
q20569 | ValueToString | train | func ValueToString(val Value) (string, bool) {
if val == nil || val.Err() {
return "", false
}
switch v := val.(type) {
case StringValue:
return v.Val(), true
case TimeValue:
return fmt.Sprintf("%v", v.Val()), true
case ByteSliceValue:
return string(v.Val()), true
case NumericValue, BoolValue, IntValue:
... | go | {
"resource": ""
} |
q20570 | IsBool | train | func IsBool(sv string) bool {
_, err := strconv.ParseBool(sv)
if err == nil {
return true
}
return false
} | go | {
"resource": ""
} |
q20571 | ValueToBool | train | func ValueToBool(val Value) (bool, bool) {
if val == nil || val.Nil() || val.Err() {
return false, false
}
switch v := val.(type) {
case NumericValue:
iv := v.Int()
if iv == 0 {
return false, true
} else if iv == 1 {
return true, true
} else {
return false, false
}
case StringValue:
bv, err ... | go | {
"resource": ""
} |
q20572 | ValueToFloat64 | train | func ValueToFloat64(val Value) (float64, bool) {
if val == nil || val.Nil() || val.Err() {
return math.NaN(), false
}
switch v := val.(type) {
case NumericValue:
return v.Float(), true
case StringValue:
return StringToFloat64(v.Val())
case BoolValue:
// Should we co-erce bools to 0/1?
if v.Val() {
re... | go | {
"resource": ""
} |
q20573 | ValueToInt | train | func ValueToInt(val Value) (int, bool) {
iv, ok := ValueToInt64(val)
return int(iv), ok
} | go | {
"resource": ""
} |
q20574 | ValueToInt64 | train | func ValueToInt64(val Value) (int64, bool) {
if val == nil || val.Nil() || val.Err() {
return 0, false
}
switch v := val.(type) {
case NumericValue:
return v.Int(), true
case StringValue:
return convertStringToInt64(0, v.Val())
case Slice:
if v.Len() > 0 {
return ValueToInt64(v.SliceValue()[0])
}
}
... | go | {
"resource": ""
} |
q20575 | StringToTimeAnchor | train | func StringToTimeAnchor(val string, anchor time.Time) (time.Time, bool) {
if len(val) > 3 && strings.ToLower(val[:3]) == "now" {
// Is date math
t, err := datemath.EvalAnchor(anchor, val)
if err != nil {
return time.Time{}, false
}
return t, true
}
t, err := dateparse.ParseAny(val)
if err == nil {
r... | go | {
"resource": ""
} |
q20576 | ValueToTime | train | func ValueToTime(val Value) (time.Time, bool) {
return ValueToTimeAnchor(val, time.Now())
} | go | {
"resource": ""
} |
q20577 | ValueToTimeAnchor | train | func ValueToTimeAnchor(val Value, anchor time.Time) (time.Time, bool) {
switch v := val.(type) {
case TimeValue:
return v.Val(), true
case StringValue:
return StringToTimeAnchor(v.Val(), anchor)
case StringsValue:
vals := v.Val()
if len(vals) < 1 {
return time.Time{}, false
}
return StringToTimeAncho... | go | {
"resource": ""
} |
q20578 | NewInsert | train | func NewInsert(ctx *plan.Context, p *plan.Insert) *Upsert {
m := &Upsert{
TaskBase: NewTaskBase(ctx),
db: p.Source,
insert: p.Stmt,
}
return m
} | go | {
"resource": ""
} |
q20579 | NewDelete | train | func NewDelete(ctx *plan.Context, p *plan.Delete) *DeletionTask {
m := &DeletionTask{
TaskBase: NewTaskBase(ctx),
db: p.Source,
sql: p.Stmt,
p: p,
}
return m
} | go | {
"resource": ""
} |
q20580 | Validate | train | func (m *Sqrt) Validate(n *expr.FuncNode) (expr.EvaluatorFunc, error) {
if len(n.Args) != 1 {
return nil, fmt.Errorf("Expected exactly 1 args for sqrt(arg) but got %s", n)
}
return sqrtEval, nil
} | go | {
"resource": ""
} |
q20581 | Validate | train | func (m *Pow) Validate(n *expr.FuncNode) (expr.EvaluatorFunc, error) {
if len(n.Args) != 2 {
return nil, fmt.Errorf("Expected 2 args for Pow(numer, power) but got %s", n)
}
return powerEval, nil
} | go | {
"resource": ""
} |
q20582 | TableToString | train | func TableToString(tbl *schema.Table) string {
w := &bytes.Buffer{}
//u.Infof("%s tbl=%p fields? %#v fields?%v", tbl.Name, tbl, tbl.FieldMap, len(tbl.Fields))
fmt.Fprintf(w, "CREATE TABLE `%s` (", tbl.Name)
for i, fld := range tbl.Fields {
if i != 0 {
w.WriteByte(',')
}
fmt.Fprint(w, "\n ")
WriteFiel... | go | {
"resource": ""
} |
q20583 | TypeFromString | train | func TypeFromString(t string) value.ValueType {
switch strings.ToLower(t) {
case "integer":
// This isn't necessarily true, as integer could be bool
return value.IntType
case "real":
return value.NumberType
default:
return value.StringType
}
} | go | {
"resource": ""
} |
q20584 | NewFilePager | train | func NewFilePager(tableName string, fs *FileSource) *FilePager {
fp := &FilePager{
fs: fs,
table: tableName,
exit: make(chan bool),
readers: make(chan *FileReader, FileBufferSize),
partid: -1,
}
return fp
} | go | {
"resource": ""
} |
q20585 | WalkExecSource | train | func (m *FilePager) WalkExecSource(p *plan.Source) (exec.Task, error) {
if m.p == nil {
m.p = p
if partitionId, ok := p.Custom.IntSafe("partition"); ok {
m.partid = partitionId
}
}
return exec.NewSource(p.Context(), p)
} | go | {
"resource": ""
} |
q20586 | NextScanner | train | func (m *FilePager) NextScanner() (schema.ConnScanner, error) {
fr, err := m.NextFile()
if err == iterator.Done {
return nil, err
} else if err != nil {
u.Warnf("NextFile Error %v", err)
return nil, err
}
scanner, err := m.fs.fh.Scanner(m.fs.store, fr)
if err != nil {
u.Errorf("Could not open file scann... | go | {
"resource": ""
} |
q20587 | NextFile | train | func (m *FilePager) NextFile() (*FileReader, error) {
select {
case <-m.exit:
// See if exit was called
return nil, iterator.Done
case fr := <-m.readers:
if fr == nil {
return nil, iterator.Done
}
return fr, nil
}
} | go | {
"resource": ""
} |
q20588 | Next | train | func (m *FilePager) Next() schema.Message {
if m.ConnScanner == nil {
m.NextScanner()
}
for {
if m.closed {
return nil
} else if m.ConnScanner == nil {
m.closed = true
return nil
}
msg := m.ConnScanner.Next()
if msg == nil {
// Kind of crap api, side-effect method? uck
_, err := m.NextScan... | go | {
"resource": ""
} |
q20589 | Init | train | func (m *Dialect) Init() {
if m.inited {
return
}
m.inited = true
for _, s := range m.Statements {
s.init()
}
} | go | {
"resource": ""
} |
q20590 | WalkProjectionFinal | train | func (m *PlannerDefault) WalkProjectionFinal(p *Select) error {
// Add a Final Projection to choose the columns for results
proj, err := NewProjectionFinal(m.Ctx, p)
//u.Infof("Projection: %T:%p %T:%p", proj, proj, proj.Proj, proj.Proj)
if err != nil {
return err
}
p.Add(proj)
if m.Ctx.Projection == nil {
... | go | {
"resource": ""
} |
q20591 | WalkSourceSelect | train | func (m *PlannerDefault) WalkSourceSelect(p *Source) error {
if p.Stmt.Source != nil {
//u.Debugf("%p VisitSubselect from.source = %q", p, p.Stmt.Source)
} else {
//u.Debugf("%p VisitSubselect from=%q", p, p)
}
// All of this is plan info, ie needs JoinKey
needsJoinKey := false
if p.Stmt.Source != nil && le... | go | {
"resource": ""
} |
q20592 | WalkLiteralQuery | train | func (m *PlannerDefault) WalkLiteralQuery(p *Select) error {
//u.Debugf("WalkLiteralQuery %+v", p.Stmt)
// Must project and possibly where
if p.Stmt.Where != nil {
u.Warnf("select literal where not implemented")
// the reason this is wrong is that the Source task gets
// added in the WalkProjectionFinal below... | go | {
"resource": ""
} |
q20593 | SourceName | train | func (m *ResultColumn) SourceName() string {
if m.Col != nil && m.Col.SourceField != "" {
return m.Col.SourceField
}
return m.Name
} | go | {
"resource": ""
} |
q20594 | CopyRewrite | train | func (m *Column) CopyRewrite(alias string) *Column {
left, right, _ := m.LeftRight()
newCol := m.Copy()
//u.Warnf("in rewrite: Alias:'%s' '%s'.'%s' sourcefield:'%v'", alias, left, right, m.SourceField)
if left == alias {
newCol.SourceField = right
newCol.right = right
}
if newCol.Expr != nil {
_, right, ... | go | {
"resource": ""
} |
q20595 | Copy | train | func (m *Column) Copy() *Column {
return &Column{
sourceQuoteByte: m.sourceQuoteByte,
asQuoteByte: m.asQuoteByte,
originalAs: m.originalAs,
ParentIndex: m.ParentIndex,
Index: m.Index,
SourceField: m.SourceField,
As: m.right,
Comment: m.Comment,
Order: ... | go | {
"resource": ""
} |
q20596 | SqlSelectFromPb | train | func SqlSelectFromPb(pb *SqlSelectPb) *SqlSelect {
ss := SqlSelect{
Db: pb.GetDb(),
Raw: pb.GetRaw(),
Star: pb.GetStar(),
Distinct: pb.GetDistinct(),
Alias: pb.GetAlias(),
Limit: int(pb.GetLimit()),
Offset: int(pb.GetOffset()),
isAgg: pb.GetIsAgg(),
finalized: pb.Get... | go | {
"resource": ""
} |
q20597 | Finalize | train | func (m *SqlSelect) Finalize() error {
if m.finalized {
return nil
}
m.finalized = true
if len(m.From) == 0 {
return nil
}
for _, from := range m.From {
from.Finalize()
}
return nil
} | go | {
"resource": ""
} |
q20598 | Rewrite | train | func (m *SqlSelect) Rewrite() {
for _, f := range m.From {
f.Rewrite(m)
}
} | go | {
"resource": ""
} |
q20599 | UnAliasedColumns | train | func (m *SqlSource) UnAliasedColumns() map[string]*Column {
//u.Warnf("un-aliased %d", len(m.Source.Columns))
if len(m.cols) > 0 || m.Source != nil && len(m.Source.Columns) == 0 {
return m.cols
}
cols := make(map[string]*Column, len(m.Source.Columns))
for _, col := range m.Source.Columns {
_, right, hasLeft :... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.