id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c20500 | if l.pos >= len(l.input) {
return true
}
// if l.Peek() == ';' {
// return true
// }
return false
} | |
c20501 | case "//":
return true
case "--":
return true
}
default:
return false
}
return false
} | |
c20502 | Line: l.line + 1, Column: l.columnNumber(), Pos: l.pos}
l.lastQuoteMark = 0
} else {
l.lastToken = Token{T: t, V: l.input[l.start:l.pos], Line: l.line + 1, Column: l.columnNumber(), Pos: l.pos}
}
l.tokens <- l.lastToken
l.start = l.pos
} | |
c20503 | len(word)
l.start = l.pos
} | |
c20504 | := l.input[l.start:l.pos]
l.start = l.pos
return str
} | |
c20505 | line position
l.line++
l.linepos = l.pos
}
}
l.backup()
l.ignore()
} | |
c20506 | l.linepos = 0
} else if !unicode.IsSpace(rune) {
break
}
rune = l.Next()
}
l.backup()
l.ignore()
return hasNewLine
} | |
c20507 |
if i < (len(l.input) - 1) {
//u.Warnf("trim: '%v'", l.input[:i+1])
l.input = l.input[:i+1]
}
break
}
}
} | |
c20508 | }
}
if l.IsEnd() {
return true
}
// If we finished looking for the match word, and the next item is not
// whitespace, it means we failed
if !isWhiteSpace(l.Peek()) {
return false
}
//u.Debugf("Found match(): %v", matchTo)
return true
} | |
c20509 | args...)
l.Emit(TokenError)
return nil
} | |
c20510 | //u.Infof("return true: %v", strings.ToLower(l.PeekX(len(clause.fullWord))))
return true
}
// TODO: allow clauses to reserve keywords, or sub-clause
switch kwMaybe {
case "select", "insert", "delete", "update", "from", "inner", "outer":
//u.Warnf("doing true: %v", kwMaybe)
return true
}
if !clau... | |
c20511 | do we need
// to also check first identifier?
// peek2 := l.PeekX(2)
// if len(peek2) == 2 {
// return isIdentifierFirstRune(rune(peek2[1]))
// }
return true
}
return isIdentifierFirstRune(r)
} | |
c20512 | > 0 {
return l.curClause.Clauses[0].Lexer
}
return l.curClause.Lexer
}
return emptyLexFn
} | |
c20513 | l.Emit(tok)
return nextFn
}
u.Warnf("unexpected token: %v peek:%s", tok, l.PeekX(20))
return l.errorToken("Unexpected token:" + l.current())
}
} | |
c20514 | identity? %s", l.PeekWord())
// by passing nil here, we are going to go back to Pull items off stack)
return LexIdentifier(l)
} else {
//u.Warnf("LexIdentityOrValue ??? -> LexValue")
return LexValue(l)
}
} | |
c20515 | %s %s", string(r), l.PeekX(20))
return l.errorToken("Unexpected token:" + l.current())
} | |
c20516 | l.Next()
l.Next()
word := strings.ToLower(l.PeekWord())
l.ConsumeWord(word)
l.Emit(TokenIdentity)
//u.Debugf("Found Sql Variable: @@%v", word)
return LexSelectList
}
//u.Debugf("not found %v", first)
if strings.HasPrefix(first, "@") {
l.Next()
word := strings.ToLower(l.PeekWord())
l... | |
c20517 | l.Emit(TokenUpsert)
return LexUpsertClause
case "into":
l.ConsumeWord(word)
l.Emit(TokenInto)
return LexUpsertClause
default:
if l.isIdentity() {
return LexTableIdentifier
}
}
return nil
} | |
c20518 | LexConditionalClause
case "from":
l.ConsumeWord(word)
l.Emit(TokenFrom)
l.Push("LexSubQuery", LexSubQuery)
l.Push("LexConditionalClause", LexConditionalClause)
return LexTableReferences
case ";":
return nil
default:
}
l.Push("LexSubQuery", LexSubQuery)
return LexSelectClause
} | |
c20519 | '%v' %v", string(r), l.PeekX(10))
switch r {
case '{', '[':
return LexJsonValue
}
//u.Warnf("Did not find json? %v", l.PeekX(20))
return nil
} | |
c20520 | // consume [
l.Emit(TokenLeftBracket)
l.Push("LexJsonArray", LexJsonArray)
return LexJsonArray
default:
// value
//u.Debugf("call lex value: %v", l.PeekX(10))
l.Push("LexJsonArray", LexJsonArray)
return LexValue(l)
}
} | |
c20521 | LexJsonObject)
l.Push("LexJsonObject", LexJsonObject)
return LexJsonIdentity // Key's must be strings
case '[':
l.Next() // consume [
l.Emit(TokenLeftBracket)
l.Push("LexJsonObject", LexJsonObject)
return LexJsonArray
}
u.Warnf("Did not find json? %v", l.PeekX(20))
return nil
} | |
c20522 | || unicode.IsDigit(r) || r == '.'
} | |
c20523 |
return true
case r == '_':
return true
}
return false
} | |
c20524 | allowedRune := range IDENTITY_CHARS {
if allowedRune == r {
return true
}
}
return false
} | |
c20525 | return false
}
break
}
return IdentityRunesOnly(identity)
} | |
c20526 | p: p,
complete: make(chan bool),
}
return m
} | |
c20527 |
m.closed = true
m.Unlock()
return m.TaskBase.Close()
} | |
c20528 | case <-ticker.C:
u.Warnf("timeout???? ")
case <-m.complete:
//u.Warnf("%p got groupbyfinal complete", m)
}
return m.TaskBase.Close()
} | |
c20529 | register: %v %T FileHandler:%p", scannerType, fh, fh)
registryMu.Lock()
defer registryMu.Unlock()
if _, dupe := scanners[scannerType]; dupe {
panic("Register called twice for FileHandler type " + scannerType)
}
scanners[scannerType] = fh
} | |
c20530 |
if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
break
}
}
return v, false
} | |
c20531 | } else if len(p.From) == 1 && p.From[0].Proj != nil {
s.Proj = p.From[0].Proj
} else {
err = s.loadFinal(ctx, true)
}
if err != nil {
return nil, err
}
return s, nil
} | |
c20532 | return value.NilValueVal, false
} | |
c20533 |
aggs: make(map[string]struct{}),
}
} | |
c20534 | {
m.mu.RLock()
fn, ok := m.funcs[name]
m.mu.RUnlock()
return fn, ok
} | |
c20535 | 2 OR 3 args for ArraySlice(array, start, [end]) but got %s", n)
}
return arraySliceEval, nil
} | |
c20536 | col.Guard, col.Guard.String())
continue
}
switch ifVal := ifColValue.(type) {
case value.BoolValue:
if ifVal.Val() == false {
continue // filter out this col
}
default:
continue
}
}
v, ok := Eval(readContext, col.Expr)
if ok {
writeContext.Put(col, readContext, v)
}
}... | |
c20537 |
return matchesExpr(cr, node, 0)
} | |
c20538 | int(dt.UnixNano() / int64(24*time.Hour))
} | |
c20539 | if incErr := vm.ResolveIncludes(fg.inc, n); incErr != nil {
return nil, incErr
}
filter, err = fg.walkExpr(n.ExprNode, depth+1)
case *expr.FuncNode:
filter, err = fg.funcExpr(n, depth+1)
default:
u.Warnf("not handled %v", node)
return nil, fmt.Errorf("qlindex: unsupported node in expression: %T (%s)", ... | |
c20540 |
m.updated(),
false,
m.FileType,
}
cols = append(cols, m.AppendCols...)
return cols
} | |
c20541 | len(parts) > 1 {
fi.PartialPath = strings.Join(parts[0:len(parts)-1], "/")
}
//u.Debugf("Fi: name=%q table=%q partial:%q partial2:%q", fi.Name, fi.Table, fi.PartialPath, partialPath)
return fi
} | |
c20542 | {
m := &Command{
TaskBase: NewTaskBase(ctx),
p: p,
}
return m
} | |
c20543 | expr.FuncResolver) *FilterQLParser {
f.funcs = funcs
return f
} | |
c20544 | return NewFilterParser(statement).ParseFilters()
} | |
c20545 | if err != nil {
return nil, err
}
// ALIAS - Optional
m.discardCommentsNewLines()
req.Alias, err = m.parseAlias()
if err != nil {
return nil, err
}
m.discardCommentsNewLines()
switch m.Cur().T {
case lex.TokenEOF, lex.TokenEOS: //, lex.TokenRightParenthesis
return req, nil
case lex.TokenError:
retu... | |
c20546 | len(dc.TimeStrings) > 0 {
dc.HasDateMath = true
}
if dc.err != nil {
return nil, dc.err
}
return dc, nil
} | |
c20547 | continue
}
// Convert ANDs to false
return MatchNone, nil
}
return nil, err
}
items = append(items, it)
}
if len(items) == 1 {
// Be nice and omit the useless boolean filter since there's only 1 item
return items[0], nil
}
var bf *BoolFilter
if and {
bf = AndFilter(items)
} else ... | |
c20548 | %v %v", m.cursor, len(m.tokens))
return eoft
}
return m.tokens[m.cursor-1]
} | |
c20549 | m.cursor < len(m.tokens))
return eoft
}
return m.tokens[m.cursor]
} | |
c20550 | 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]
} | |
c20551 | expected {
t.unexpected(token, context)
}
return token
} | |
c20552 | err = fmt.Errorf("parse error: %v", p)
}
}()
return t.O(0), err
} | |
c20553 | = funcReg.FuncGet(strings.ToLower(name)); ok {
return
}
return
} | |
c20554 | {
gr, err := gzip.NewReader(buf)
if err != nil {
u.Warnf("could not open gzip reader: %v", err)
return nil, err
}
js.gz = gr
js.r = bufio.NewReader(gr)
} else {
js.r = buf
}
if lh == nil {
js.lh = js.jsonDefaultLine
}
//m.loadTable()
return js, nil
} | |
c20555 | {
m := &Create{
TaskBase: NewTaskBase(ctx),
p: p,
}
return m
} | |
c20556 | {
m := &Drop{
TaskBase: NewTaskBase(ctx),
p: p,
}
return m
} | |
c20557 | {
m := &Alter{
TaskBase: NewTaskBase(ctx),
p: p,
}
return m
} | |
c20558 | := NewStaticDataSource(name, 0, [][]driver.Value{row}, []string{name})
return ds
} | |
c20559 | {
return &defaultDialect{LiteralQuote: l, IdentityQuote: i}
} | |
c20560 | return
}
LiteralQuoteEscapeBuf(&w.Buffer, rune(w.LiteralQuote), l)
} | |
c20561 | return
}
IdentityMaybeEscapeBuf(&w.Buffer, w.IdentityQuote, i)
} | |
c20562 | 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
} | |
c20563 | 1 && i == "*" {
w.WriteByte('*')
return
}
LiteralQuoteEscapeBuf(&w.Buffer, rune(w.IdentityQuote), i)
} | |
c20564 |
return
}
w.Buffer.WriteString(strconv.Quote(l))
} | |
c20565 |
if p.Final {
return NewWhereFinal(ctx, p)
}
return NewWhereFilter(ctx, p.Stmt)
} | |
c20566 |
cols := sql.ColIndexes()
s.Handler = whereFilter(s.filter, s, cols)
return s
} | |
c20567 | }
case TimeType:
t, ok := ValueToTime(val)
if ok {
return NewTimeValue(t), nil
}
case StringType:
return NewStringValue(val.ToString()), nil
case IntType:
iv, ok := ValueToInt64(val)
if ok {
return NewIntValue(iv), nil
}
return nil, ErrConversion
}
return nil, ErrConversionNotSupported
} | |
c20568 | case Slice:
if rhv, ok := r.(Slice); ok {
if lt.Len() != rhv.Len() {
return false, nil
}
rhslice := rhv.SliceValue()
for i, lhval := range lt.SliceValue() {
if eq, err := Equal(lhval, rhslice[i]); !eq || err != nil {
return false, nil
}
}
return true, nil
}
}
return false, fmt.... | |
c20569 |
// This is controversial, if we are demanding a "ToString"
// should we:
// 1) take first?
// 2) append comma separated?
// 3) error?
//
// Our answer is that we are demanding a scalar string
// and going to take first. calling function would have had to do type detection
// if they wanted someth... | |
c20570 | nil {
return true
}
return false
} | |
c20571 | bv, err := strconv.ParseBool(v.Val())
if err != nil {
return false, false
}
return bv, true
case BoolValue:
return v.Val(), true
}
return false, false
} | |
c20572 | Should we co-erce bools to 0/1?
if v.Val() {
return float64(1), true
}
return float64(0), true
}
return math.NaN(), false
} | |
c20573 | := ValueToInt64(val)
return int(iv), ok
} | |
c20574 | StringValue:
return convertStringToInt64(0, v.Val())
case Slice:
if v.Len() > 0 {
return ValueToInt64(v.SliceValue()[0])
}
}
return 0, false
} | |
c20575 | time.Time{}, false
}
return t, true
}
t, err := dateparse.ParseAny(val)
if err == nil {
return t, true
}
return time.Time{}, false
} | |
c20576 | ValueToTimeAnchor(val, time.Now())
} | |
c20577 | return time.Time{}, false
}
if t.Year() < 1800 || t.Year() > 2120 {
return t, false
}
return t, true
default:
//u.Warnf("un-handled type to time? %#v", val)
}
return time.Time{}, false
} | |
c20578 | p.Source,
insert: p.Stmt,
}
return m
} | |
c20579 | p.Source,
sql: p.Stmt,
p: p,
}
return m
} | |
c20580 | 1 args for sqrt(arg) but got %s", n)
}
return sqrtEval, nil
} | |
c20581 | args for Pow(numer, power) but got %s", n)
}
return powerEval, nil
} | |
c20582 |
}
fmt.Fprint(w, "\n);")
//tblStr := fmt.Sprintf("CREATE TABLE `%s` (\n\n);", tbl.Name, strings.Join(cols, ","))
//return tblStr, nil
return w.String()
} | |
c20583 | return value.IntType
case "real":
return value.NumberType
default:
return value.StringType
}
} | |
c20584 | readers: make(chan *FileReader, FileBufferSize),
partid: -1,
}
return fp
} | |
c20585 | ok {
m.partid = partitionId
}
}
return exec.NewSource(p.Context(), p)
} | |
c20586 | if err != nil {
u.Errorf("Could not open file scanner %v err=%v", m.fs.fileType, err)
return nil, err
}
m.ConnScanner = scanner
return scanner, err
} | |
c20587 | fr := <-m.readers:
if fr == nil {
return nil, iterator.Done
}
return fr, nil
}
} | |
c20588 | _, err := m.NextScanner()
if err != nil {
if err == iterator.Done {
// Truly was last file in partition
m.closed = true
return nil
} else {
u.Errorf("unexpected end of scan %v", err)
return nil
}
}
// now that we have a new scanner, lets try again
if m.ConnScanner != ... | |
c20589 | s := range m.Statements {
s.init()
}
} | |
c20590 | err
}
p.Add(proj)
if m.Ctx.Projection == nil {
m.Ctx.Projection = proj
} else {
// Not entirely sure we should be over-writing the projection?
}
return nil
} | |
c20591 | schema.ConnColumns: %T", p.Stmt.SourceName(), p.Conn)
}
if p.Stmt.Source != nil && p.Stmt.Source.Where != nil {
switch {
case p.Stmt.Source.Where.Expr != nil:
p.Add(NewWhere(p.Stmt.Source))
default:
u.Warnf("Found un-supported where type: %#v", p.Stmt.Source)
return fmt.Errorf("Unsupported Wh... | |
c20592 |
err := m.WalkProjectionFinal(p)
//u.Debugf("m.Ctx: %p m.Ctx.Projection.Proj:%p ", m.Ctx, m.Ctx.Projection.Proj)
if err != nil {
u.Errorf("error projecting literal? %#v", err)
return err
}
return nil
} | |
c20593 | return m.Col.SourceField
}
return m.Name
} | |
c20594 |
if left == alias {
newCol.SourceField = right
newCol.right = right
}
if newCol.Expr != nil {
_, right, _ := expr.LeftRight(newCol.Expr.String())
if right == m.SourceField {
newCol.Expr = &expr.IdentityNode{Text: right}
}
}
return newCol
} | |
c20595 | m.right,
Comment: m.Comment,
Order: m.Order,
Star: m.Star,
Expr: m.Expr,
Guard: m.Guard,
}
} | |
c20596 | {
ss.Columns = ColumnsFromPb(pb.GetColumns())
}
if len(pb.GroupBy) > 0 {
ss.GroupBy = ColumnsFromPb(pb.GetGroupBy())
}
if len(pb.OrderBy) > 0 {
ss.OrderBy = ColumnsFromPb(pb.GetOrderBy())
}
if len(pb.From) > 0 {
ss.From = make([]*SqlSource, len(pb.From))
for i, fpb := range pb.From {
ss.From[i] = Sq... | |
c20597 | true
if len(m.From) == 0 {
return nil
}
for _, from := range m.From {
from.Finalize()
}
return nil
} | |
c20598 | := range m.From {
f.Rewrite(m)
}
} | |
c20599 | right, hasLeft := col.LeftRight()
//u.Debugf("aliasing: l:%q r:%q hasLeft?%v", left, right, hasLeft)
if hasLeft {
cols[right] = col
} else {
cols[right] = col
}
}
return cols
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.