id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c14600 | checkLikeExp(I_LIKE_OP, lhs, val, true)
} | |
c14601 | if op == LIKE_OP {
op = REGEXP_LIKE_OP
} else if op == I_LIKE_OP {
op = REGEXP_I_LIKE_OP
}
rhs = val.(*regexp.Regexp).String()
}
if invert {
op = operator_inversions[op]
}
return boolean{op: op, lhs: lhs, rhs: rhs}
} | |
c14602 | BETWEEN_OP, lhs: lhs, rhs: rhs}
} | |
c14603 | {
return ranged{op: NBETWEEN_OP, lhs: lhs, rhs: rhs}
} | |
c14604 | aliasExpression{aliased: exp, alias: v}
default:
panic(fmt.Sprintf("Cannot create alias from %+v", v))
}
} | |
c14605 | exp, direction: SORT_ASC, nullSortType: NO_NULLS}
} | |
c14606 | exp, direction: SORT_DESC, nullSortType: NO_NULLS}
} | |
c14607 | {
return sqlFunctionExpression{name: name, args: args}
} | |
c14608 |
col = I(s)
}
return Func(name, col)
} | |
c14609 | recursive, name: Literal(name), subQuery: subQuery}
} | |
c14610 | return me.InnerJoin(table, condition)
} | |
c14611 | return me.joinTable(INNER_JOIN, table, condition)
} | |
c14612 | return me.joinTable(FULL_OUTER_JOIN, table, condition)
} | |
c14613 | return me.joinTable(RIGHT_OUTER_JOIN, table, condition)
} | |
c14614 | return me.joinTable(LEFT_OUTER_JOIN, table, condition)
} | |
c14615 | return me.joinTable(FULL_JOIN, table, condition)
} | |
c14616 | return me.joinTable(RIGHT_JOIN, table, condition)
} | |
c14617 | return me.joinTable(LEFT_JOIN, table, condition)
} | |
c14618 | me.joinTable(NATURAL_JOIN, table, nil)
} | |
c14619 | me.joinTable(NATURAL_LEFT_JOIN, table, nil)
} | |
c14620 | me.joinTable(NATURAL_RIGHT_JOIN, table, nil)
} | |
c14621 | me.joinTable(NATURAL_FULL_JOIN, table, nil)
} | |
c14622 | me.joinTable(CROSS_JOIN, table, nil)
} | |
c14623 | = append(ret.clauses.Joins, JoiningClause{JoinType: joinType, IsConditioned: isConditioned, Table: table, Condition: condition})
return ret
} | |
c14624 |
ret.clauses.Where = ret.clauses.Where.Append(expressions...)
}
return ret
}
return me
} | |
c14625 | me.copy()
ret.clauses.Where = nil
return ret
} | |
c14626 | me.copy()
ret.clauses.GroupBy = cols(groupBy...)
return ret
} | |
c14627 | me.copy()
ret.clauses.Order = orderList(order...)
return ret
} | |
c14628 | me.copy()
ret.clauses.Order = ret.clauses.Order.Append(orderList(order...).Columns()...)
return ret
}
return me
} | |
c14629 | me.copy()
ret.clauses.Order = nil
return ret
} | |
c14630 | = limit
} else {
ret.clauses.Limit = nil
}
return ret
} | |
c14631 | := me.copy()
ret.clauses.Limit = Literal("ALL")
return ret
} | |
c14632 | me.copy()
ret.clauses.Offset = offset
return ret
} | |
c14633 |
ret.clauses.Compounds = append(ret.clauses.Compounds, Intersect(other.compoundFromSelf()))
return ret
} | |
c14634 | != nil || me.clauses.Limit != nil {
return me.FromSelf()
}
return me.copy()
} | |
c14635 | me.copy()
ret.clauses.Returning = cols(returning...)
return ret
} | |
c14636 | me.copy()
ret.clauses.Alias = I(alias)
return ret
} | |
c14637 |
return err
}
if err := me.adapter.JoinSql(buf, me.clauses.Joins); err != nil {
return err
}
if err := me.adapter.WhereSql(buf, me.clauses.Where); err != nil {
return err
}
if err := me.adapter.GroupBySql(buf, me.clauses.GroupBy); err != nil {
return err
}
if err := me.adapter.HavingSql(buf, me.clauses.... | |
c14638 | productName = lookup(lang, "adjectives", true) + " " + productName
}
return productName
} | |
c14639 |
return CharactersN(r.Intn(3)+1) + seps[r.Intn(len(seps))] + Digits()
} | |
c14640 | return Character() + lookup(lang, gender+"_last_names", false)
default:
return strings.Replace(WordsN(r.Intn(3)+1), " ", "_", -1)
}
} | |
c14641 | ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To4().String()
} | |
c14642 | ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To16().String()
} | |
c14643 | digits[i] = numeric[r.Intn(len(numeric))]
}
return string(digits)
} | |
c14644 | strconv.Itoa(card.prefixes[r.Intn(len(card.prefixes))])
num := []rune(prefix)
for i := 0; i < card.length-len(prefix); i++ {
num = append(num, genCCDigit(num))
}
return string(num)
} | |
c14645 | case 1:
return join(city, citySuffix())
default:
return city
}
} | |
c14646 | = append(chars, Character())
}
return strings.Join(chars, "")
} | |
c14647 | {
words[i] = Word()
}
return strings.Join(words, " ")
} | |
c14648 | sentence := strings.Join(words, " ")
if r.Intn(8) == 0 {
sentence += "!"
} else {
sentence += "."
}
return sentence
} | |
c14649 | {
sentences[i] = Sentence()
}
return strings.Join(sentences, " ")
} | |
c14650 | append(paragraphs, Paragraph())
}
return strings.Join(paragraphs, "\t")
} | |
c14651 | + 1
return from + n
} | |
c14652 | k != "/" && k != "/data" {
langs = append(langs, strings.Replace(k, "/data/", "", 1))
}
}
return langs
} | |
c14653 |
}
if !found {
return ErrNoLanguageFn(newLang)
}
lang = newLang
return nil
} | |
c14654 | true)
return strings.Replace(job, "#{N}", jobTitleSuffix(), 1)
} | |
c14655 |
formatterFormat = "text"
AssignmentChar = ltsvAssignmentChar
Separator = ltsvSeparator
}
}
if formatterFormat == "" || formatterCreators[formatterFormat] == nil {
formatterFormat = defaultFormat
}
logxiFormat = formatterFormat
if tFormat == "" {
tFormat = defaultTimeFormat
}
timeFormat = tFormat
... | |
c14656 | } else if value == "" {
// LOGXI=* => default to all
logxiNameLevelMap[key] = LevelAll
} else {
// LOGXI=*=ERR => use user-specified level
level := LevelAtoi[value]
if level == 0 {
InternalLog.Error("Unknown level in LOGXI environment variable", "key", key, "value", value, "LOGXI", env)
level ... | |
c14657 | // disable all colors
disableColors = true
}
theme = parseTheme(colors)
} | |
c14658 | if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
jf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
jf.set(buf, warnImb... | |
c14659 | panic("creator is nil")
}
formatterCreators[kind] = fn
} | |
c14660 | NewJSONFormatter(name)
return &HappyDevFormatter{
name: name,
jsonFormatter: jf,
}
} | |
c14661 |
buf.WriteString(s)
hd.col += len(s)
} | |
c14662 | panic("Could not create formatter")
}
return NewLogger3(writer, name, formatter)
} | |
c14663 | name,
level: level,
}
// TODO loggers will be used when watching changes to configuration such
// as in consul, etcd
loggers.Lock()
loggers.loggers[name] = log
loggers.Unlock()
return log
} | |
c14664 | l.Log(LevelTrace, msg, args)
} | |
c14665 | l.Log(LevelDebug, msg, args)
} | |
c14666 | l.Log(LevelInfo, msg, args)
} | |
c14667 | := arg.(error); ok {
return err
}
}
return nil
}
return nil
} | |
c14668 | l.extractLogError(LevelError, msg, args)
} | |
c14669 | args)
defer panic("Exit due to fatal error: ")
} | |
c14670 | l.level < level || silent {
return
}
l.formatter.Format(l.writer, level, msg, args)
} | |
c14671 | }
itoaLevelMap := map[int]string{
LevelDebug: buildKV(LevelMap[LevelDebug]),
LevelWarn: buildKV(LevelMap[LevelWarn]),
LevelInfo: buildKV(LevelMap[LevelInfo]),
LevelError: buildKV(LevelMap[LevelError]),
LevelFatal: buildKV(LevelMap[LevelFatal]),
}
return &TextFormatter{itoaLevelMap: itoaLevelMap, name: n... | |
c14672 | } else {
tf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
tf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteRune('\n')
buf.WriteTo(writer)
} | |
c14673 | make(map[string]interface{}),
fileType: UnknownFileType,
}
err := m.readAtoms(r)
return m, err
} | |
c14674 | _, err := r.Seek(4, io.SeekCurrent)
if err != nil {
return "", err
}
fallthrough
case "moov", "udta", "ilst":
continue
case "mdat": // stop when we get to the data
h := sha1.New()
_, err := io.CopyN(h, r, int64(size-8))
if err != nil {
return "", fmt.Errorf("error reading audio dat... | |
c14675 | "\n"))
}
return fmt.Sprintf("Text{Description: '%v', %v}", t.Description, t.Text)
} | |
c14676 | p.Ext, p.MIMEType, p.Type, p.Description, len(p.Data))
} | |
c14677 | err := readBytes(r, 1)
if err != nil {
return nil, err
}
if int(genreID[0]) < len(id3v1Genres) {
genre = id3v1Genres[int(genreID[0])]
}
m := make(map[string]interface{})
m["title"] = trimString(title)
m["artist"] = trimString(artist)
m["album"] = trimString(album)
m["year"] = trimString(year)
m["comment... | |
c14678 |
format = ID3v2_3
case 4:
format = ID3v2_4
case 0, 1:
fallthrough
default:
err = fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
return
}
return format, MP3, nil
}
n, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return
}
tag, err := readString(r, 3)
if err != nil {
... | |
c14679 | get7BitChunkedInt(b[3:7]),
}
if h.ExtendedHeader {
switch vers {
case ID3v2_3:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v23 extended header len): %v", err)
}
// skip header, size is excluding len bytes
extendedHeaderSize := get... | |
c14680 | if r.ff && b[0] == 0x00 {
r.ff = false
continue
}
p[i] = b[0]
i++
r.ff = (b[0] == 0xFF)
}
return i, nil
} | |
c14681 | + genre
}
if match[3] != "" {
genre = genre + " " + match[3]
}
}
}
}
c = (orig != genre)
}
return strings.Replace(genre, "((", "(", -1)
} | |
c14682 | {
last, err := m.readFLACMetadataBlock(r)
if err != nil {
return nil, err
}
if last {
break
}
}
return m, nil
} | |
c14683 | v
return
}
for k, tt := range tags {
if tt == t {
i[k] = v
return
}
}
} | |
c14684 | &Plugin{name: name, logFn: fn}
} | |
c14685 | "snapshot"
case LogTypeHealth:
typeString = "health"
case LogTypeInit:
typeString = "init"
case LogTypeStatus:
typeString = "status"
default:
typeString = "unknown"
}
return typeString
} | |
c14686 | return nil, errors.Wrapf(err, "dialing pipe '%s'", path)
}
return thrift.NewTSocketFromConnTimeout(conn, timeout), nil
} | |
c14687 | != nil {
return nil, thrift.NewTTransportExceptionFromError(err)
}
return thrift.NewTSocketFromConnTimeout(conn, p.clientTimeout), nil
} | |
c14688 | timeout: defaultTimeout,
pingInterval: defaultPingInterval,
}
for _, opt := range opts {
opt(manager)
}
serverClient, err := NewClient(sockPath, manager.timeout)
if err != nil {
return nil, err
}
manager.serverClient = serverClient
return manager, nil
} | |
c14689 | panic("invalid registry name: " + plugin.RegistryName())
}
s.registry[plugin.RegistryName()][plugin.Name()] = plugin
}
} | |
c14690 | if status.Code != 0 {
errc <- errors.Errorf("ping returned status %d", status.Code)
break
}
}
}()
err := <-errc
if err := s.Shutdown(context.Background()); err != nil {
return err
}
return err
} | |
c14691 | &osquery.ExtensionStatus{Code: 0, Message: "OK"}, nil
} | |
c14692 |
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry item: " + item,
},
}, nil
}
response := plugin.Call(context.Background(), request)
return &response, nil
} | |
c14693 | to deadlock if a
// shutdown request is being processed when shutdown is
// explicitly called.
go func() {
server.Stop()
}()
}
return nil
} | |
c14694 | if started {
time.Sleep(10 * time.Millisecond)
break
}
}
} | |
c14695 | &Plugin{name: name, generate: fn}
} | |
c14696 | if err := waitForSocket(sockPath, timeout); err != nil {
return nil, errors.Wrapf(err, "waiting for unix socket to be available: %s", sockPath)
}
trans := thrift.NewTSocketFromAddrTimeout(addr, timeout)
if err := trans.Open(); err != nil {
return nil, errors.Wrap(err, "opening socket transport")
}
return tr... | |
c14697 | trans,
thrift.NewTBinaryProtocolFactoryDefault(),
)
return &ExtensionManagerClient{client, trans}, nil
} | |
c14698 | != nil && c.transport.IsOpen() {
c.transport.Close()
}
} | |
c14699 | c.Client.Ping(context.Background())
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.