id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c20400 | return c.DiffInSeconds(d, abs) / secondsPerMinute
} | |
c20401 |
diff := carb.Timestamp() - c.Timestamp()
return absValue(abs, diff)
} | |
c20402 | return int(c.DiffInSeconds(startOfDay, true))
} | |
c20403 |
return -value
}
return value
} | |
c20404 | = c.AddDay()
}
return c.StartOfDay()
} | |
c20405 | !c.IsWeekend() {
c = c.AddDay()
}
return c
} | |
c20406 |
for !c.IsWeekend() {
c = c.SubDay()
}
return c
} | |
c20407 | c = c.SubDay()
}
return c.StartOfDay()
} | |
c20408 |
d := c.StartOfMonth()
if d.Weekday() != wd {
return d.Next(wd)
}
return d
} | |
c20409 | return d.Previous(wd)
}
return d.StartOfDay()
} | |
c20410 | c.Month(), c.DaysInMonth(), 0, 0, 0, 0, time.UTC))
} | |
c20411 | NewCarbon(time.Date(c.Year(), c.Month(), 1, 0, 0, 0, 0, time.UTC))
} | |
c20412 | < nth {
cp = cp.Next(wd)
i++
}
if cp.Gt(c.EndOfMonth()) {
return c
}
return cp
} | |
c20413 |
d := c.StartOfQuarter()
if d.Weekday() != wd {
return d.Next(wd)
}
return d
} | |
c20414 | return d.Previous(wd)
}
return d.StartOfDay()
} | |
c20415 | < nth {
cp = cp.Next(wd)
i++
}
if cp.Gt(c.EndOfQuarter()) {
return c
}
return cp
} | |
c20416 |
d := c.StartOfYear()
if d.Weekday() != wd {
return d.Next(wd)
}
return d
} | |
c20417 | return d.Previous(wd)
}
return d.StartOfDay()
} | |
c20418 | < nth {
cp = cp.Next(wd)
i++
}
if cp.Gt(c.EndOfYear()) {
return c
}
return cp
} | |
c20419 | }
if c.Eq(carb) {
return c.Copy()
}
average := int(c.DiffInSeconds(carb, false) / 2)
return c.AddSeconds(average)
} | |
c20420 | c.Translator == nil {
c.Translator = translator()
}
return c.Translator, nil
} | |
c20421 | != nil {
return err
}
return nil
} | |
c20422 | start date.")
}
return &CarbonInterval{
Start: start,
End: end,
}, nil
} | |
c20423 | ci.End.DiffInHours(ci.Start, true)
} | |
c20424 | err != nil {
return err
}
err = t.loadResource(l)
if err != nil {
return err
}
t.locale = l
return nil
} | |
c20425 | err.Error())
}
if !matched {
return errors.New("invalid locale code : " + l)
}
return nil
} | |
c20426 |
}
err = json.Unmarshal(ltext, &t.resources)
if err != nil {
return errors.New("unable to unmarshall locale data : " + err.Error())
}
return nil
} | |
c20427 | return strings.Replace(s[1], ":count", strconv.FormatInt(int64(count), 10), 1), nil
}
return s[0], nil
} | |
c20428 | strings.Replace(t.resources[transID], ":time", time, 1)
} | |
c20429 | l + ".json")
if err != nil {
return nil, errors.New("not able to read the lang file:" + err.Error())
}
return lText, nil
} | |
c20430 | t.FailNow, os.Stdout, !noColorFlag}
} | |
c20431 | os.Stdout, !noColorFlag}
} | |
c20432 | // no comment
}
text = text[commentI+2:]
text = strings.TrimSpace(text)
return text, true
}
i++
}
return "", false
} | |
c20433 | j := 0
c := 1
for cs.Scan() {
switch cs.Text() {
case ")":
c--
case "(":
c++
}
if c == 0 {
break
}
j++
}
text = text[:j]
return text, true
}
i++
}
return "", false
} | |
c20434 | buf.WriteString("\n\t\t")
}
// expand arguments (if $ARGS is present)
if strings.Contains(line, "$ARGS") {
args, _ := loadArguments(path, lineNumber)
line = strings.Replace(line, "$ARGS", args, -1)
}
buf.WriteString(line)
}
comment, ok := loadComment(path, lineNumber)
if ok {
if is.colorful {
b... | |
c20435 |
l.backup()
return l.errorToken("Unexpected token:" + l.current())
} | |
c20436 | ",":
l.ConsumeWord(keyWord)
l.Emit(TokenComma)
return LexNumber
default:
if isDigit(l.Peek()) {
l.Push("LexLimit", LexLimit)
return LexNumber
}
}
return nil
} | |
c20437 | of columns
l.Emit(TokenRightParenthesis)
return LexDdlTableStorage
case '-', '/': // comment?
p := l.Peek()
if p == '-' {
l.backup()
l.Push("LexDdlTable", LexDdlTable)
return LexInlineComment
}
u.Warnf("unhandled comment non inline ")
case ';':
l.backup()
return nil
}
l.backup()
word := ... | |
c20438 | return err
}
var name, sql string
for rows.Next() {
rows.Scan(&name, &sql)
name = strings.ToLower(name)
t := tableFromSQL(name, sql)
m.tables[name] = t
m.tableList = append(m.tableList, name)
}
rows.Close()
// if err := datasource.IntrospectTable(m.tbl, m.CreateIterator()); err != nil {
// u.Errorf(... | |
c20439 | m.tblmu.Unlock()
if !ok {
return nil, schema.ErrNotFound
}
m.mu.Lock()
//u.Infof("after open lock")
qc := newQueryConn(t, m)
m.qryconns[table] = qc
return qc, nil
} | |
c20440 | m.tblmu.Unlock()
if !ok {
return nil, schema.ErrNotFound
}
return t, nil
} | |
c20441 |
return err
}
m.db = nil
}
return nil
} | |
c20442 | panic(e)
case error:
*errp = err
default:
panic(e)
}
}
} | |
c20443 | return value.NilValueVal, false
}
return value.NewNumberValue(fv), true
}
u.Debugf("Could not find numeric conversion for %#v", t)
return value.NilValueVal, false
} | |
c20444 | return resolveIncludesDepth(ctx, arg, 0)
} | |
c20445 | if av > bv && av < cv {
return value.NewBoolValue(true), true
}
return value.NewBoolValue(false), true
case value.NumberValue:
av := at.Val()
bv, ok := value.ValueToFloat64(b)
if !ok {
return nil, false
}
cv, ok := value.ValueToFloat64(c)
if !ok {
return nil, false
}
if ... | |
c20446 | len(node.Args))
for i, a := range node.Args {
v, ok := Eval(ctx, a)
if !ok {
v = value.NewNilValue()
}
args[i] = v
}
return node.Eval(ctx, args)
} | |
c20447 |
if err != nil {
return value.BoolValueFalse, false
}
if match {
return value.BoolValueTrue, true
}
return value.BoolValueFalse, true
} | |
c20448 | make(u.JsonHelper)
if err := json.Unmarshal(data, &jh); err != nil {
return err
}
*m = JsonHelperScannable(jh)
return nil
} | |
c20449 | err := json.Marshal(m)
return by, err
} | |
c20450 | return doInlineIncludes(ctx, n, 0)
} | |
c20451 | *rel.PreparedStatement:
p = &PreparedStatement{Stmt: st, PlanBase: base}
case *rel.SqlCommand:
p = &Command{Stmt: st, PlanBase: base, Ctx: ctx}
case *rel.SqlCreate:
p = &Create{Stmt: st, PlanBase: base, Ctx: ctx}
case *rel.SqlDrop:
p = &Drop{Stmt: st, PlanBase: base, Ctx: ctx}
case *rel.SqlAlter:
p = &Al... | |
c20452 | err
}
switch {
case p.Select != nil:
return SelectFromPB(p, loader)
}
return nil, ErrNotImplemented
} | |
c20453 | nil:
return GroupByFromPB(pb), nil
case pb.Order != nil:
return OrderFromPB(pb), nil
case pb.Projection != nil:
return ProjectionFromPB(pb, sel), nil
case pb.JoinMerge != nil:
u.Warnf("JoinMerge not implemented: %T", pb)
case pb.JoinKey != nil:
u.Warnf("JoinKey not implemented: %T", pb)
default:
u.War... | |
c20454 | stmt, PlanBase: NewPlanBase(false), Ctx: ctx}
} | |
c20455 | stmt, PlanBase: NewPlanBase(false), Ctx: ctx}
} | |
c20456 | stmt, PlanBase: NewPlanBase(false), Ctx: ctx}
} | |
c20457 | stmt, ctx: ctx, SourcePb: &SourcePb{Final: isFinal}, PlanBase: NewPlanBase(false)}
err := s.load()
if err != nil {
return nil, err
}
return s, nil
} | |
c20458 | return false
}
s, ok := t.(*Projection)
if !ok {
return false
}
if m.Final != s.Final {
return false
}
if !m.Proj.Equal(s.Proj) {
return false
}
if !m.PlanBase.EqualBase(s.PlanBase) {
return false
}
return true
} | |
c20459 |
return nil, err
}
ppbptr := m.Proj.ToPB()
ppcpy := *ppbptr
ppcpy.Final = m.Final
pbp.Projection = &ppcpy
return pbp, nil
} | |
c20460 | m.Final = pb.Projection.Final
m.PlanBase = NewPlanBase(pb.Parallel)
m.Stmt = sel
return &m
} | |
c20461 | return &JoinKey{Source: s, PlanBase: NewPlanBase(false)}
} | |
c20462 | stmt, PlanBase: NewPlanBase(false)}
} | |
c20463 | Final: true, PlanBase: NewPlanBase(false)}
} | |
c20464 | stmt, PlanBase: NewPlanBase(false)}
} | |
c20465 | stmt, PlanBase: NewPlanBase(false)}
} | |
c20466 | stmt, PlanBase: NewPlanBase(false)}
} | |
c20467 |
s, ok := t.(*Into)
if !ok {
return false
}
if !m.PlanBase.EqualBase(s.PlanBase) {
return false
}
return true
} | |
c20468 | err = m.walkGroupBy()
if err != nil {
u.Warnf("Could Not evaluate GroupBys %s %v", m.sel.GroupBy.String(), err)
return "", err
}
}
if len(m.sel.OrderBy) > 0 {
// this should be same right?
m.result.OrderBy = m.sel.OrderBy
}
return m.result.String(), nil
} | |
c20469 | {
colsToAdd := expr.FindAllIdentityField(m.Where.Expr)
addIntoProjection(m, colsToAdd)
}
rewriteIntoProjection(m, m.OrderBy)
} | |
c20470 | which need to be re-written
sql2.Columns = columnsFromJoin(m, from.JoinExpr, sql2.Columns)
// We also need to create an expression used for evaluating
// the values of Join "Keys"
if from.JoinExpr != nil {
joinNodesForFrom(parentStmt, m, from.JoinExpr, 0)
}
}
if parentStmt.Where != nil {
node, cols ... | |
c20471 | return n
}
u.Warnf("Could not find node: %#v", node)
default:
u.Warnf("un-implemented op: %v", nt.Operator)
}
case *expr.FuncNode:
fn := expr.NewFuncNode(nt.Name, nt.F)
fn.Args = make([]expr.Node, len(nt.Args))
for i, arg := range nt.Args {
fn.Args[i] = rewriteNode(from, arg)
if fn.Args[i] ==... | |
c20472 |
case value.StringValue:
matchKey := fv.ToString()
if strings.Contains(matchKey, "%") {
matchKey = strings.Replace(matchKey, "%", "*", -1)
}
filters = append(filters, matchKey)
}
}
return filters
} | |
c20473 | n.Value.(floatval)
if !ok {
return nil, false
}
return nn.Float(), true
}
case *expr.IdentityNode:
if _, err := strconv.ParseBool(n.Text); err == nil {
return n.Text, true
}
}
return "", false
} | |
c20474 | {
case value.StringValue:
return sv, true
}
return value.NewStringValue(""), false
} | |
c20475 |
s.mu.Lock()
delete(m.reg.schemas, s.Name)
names := make([]string, 0, len(m.reg.schemaNames))
for _, n := range m.reg.schemaNames {
if s.Name != n {
names = append(names, n)
}
}
m.reg.schemaNames = names
s.refreshSchemaUnlocked()
s.mu.Unlock()
m.reg.mu.Unlock()
default:
u.Errorf("inval... | |
c20476 | flagCsvDelimiter == "\t" || flagCsvDelimiter == "t" {
// m.csvr.Comma = '\t'
// }
headers, err := m.csvr.Read()
if err != nil {
u.Warnf("err csv %v", err)
return nil, err
}
//u.Debugf("headers: %v", headers)
m.headers = headers
m.colindex = make(map[string]int, len(headers))
for i, key := range headers {... | |
c20477 | conn.Close()
for _, row := range data {
conn.Put(nil, nil, row)
}
// we are going to look at ~10 rows to create schema for it
if err = datasource.IntrospectTable(m.tbl, conn); err != nil {
u.Errorf("Could not introspect schema %v", err)
return nil, err
}
return m, nil
} | |
c20478 | return NewMemDbForSchema(name, cols)
} | |
c20479 |
m.buildDefaultIndexes()
mdbSchema := makeMemDbSchema(m)
m.db, err = memdb.NewMemDB(mdbSchema)
return m, err
} | |
c20480 | u.Errorf("could not delete %v", err)
break deleteLoop
}
indexVal := msg.Vals[0]
deletedKeys = append(deletedKeys, schema.NewKeyUint(makeId(indexVal)))
}
case nil:
// ??
u.Warnf("this should be fine, couldn't evaluate so don't delete %v", msg)
default:
if whereVal.Nil() {
// Does... | |
c20481 | return MapStringType
case "map[string]number":
return MapNumberType
case "map[string]bool":
return MapBoolType
case "map[string]time":
return MapTimeType
case "[]value":
return SliceValueType
case "struct":
return StructType
case "json":
return JsonType
default:
return UnknownType
}
} | |
c20482 | make(IdentityNodes, 0)
return findIdentities(node, in)
} | |
c20483 | in := range m {
s[i] = in.Text
}
return s
} | |
c20484 | in := range m {
l, r, hasLr := in.LeftRight()
if hasLr {
s[i] = l
} else {
s[i] = r
}
}
return s
} | |
c20485 | return value.BoolType
case lex.TokenMultiply, lex.TokenMinus, lex.TokenAdd, lex.TokenDivide:
return value.NumberType
case lex.TokenModulus:
return value.IntType
case lex.TokenLT, lex.TokenLE, lex.TokenGT, lex.TokenGE:
return value.BoolType
}
}
return value.UnknownType
} | |
c20486 | &FuncNode{Name: name, F: f}
} | |
c20487 |
fe.Args = append(fe.Args, ExprsFromNodes(m.Args)...)
}
return fe
} | |
c20488 | := &NumberNode{Text: text}
return n, n.load()
} | |
c20489 | operator, rhArg)
return &BooleanNode{Args: args, Operator: operator}
} | |
c20490 | &TriNode{Args: []Node{arg1, arg2, arg3}, Operator: operator}
} | |
c20491 | return nil, err
}
return NodeFromNodePb(n), nil
} | |
c20492 | *NumberNode
return nn.FromPB(n)
case n.Vn != nil:
var vn *ValueNode
return vn.FromPB(n)
case n.In != nil:
var in *IdentityNode
return in.FromPB(n)
case n.Sn != nil:
var sn *StringNode
return sn.FromPB(n)
case n.Incn != nil:
var in *IncludeNode
return in.FromPB(n)
case n.Niln != nil:
return &Nu... | |
c20493 | dialect,
}
if len(dialect.IdentityQuoting) > 0 {
l.identityRunes = dialect.IdentityQuoting
} else {
l.identityRunes = IdentityQuoting
}
l.init()
return l
} | |
c20494 |
}
if len(msg) > 0 {
return fmt.Errorf("%s Got %s near: %s", msg, t.String(), raw)
}
return fmt.Errorf("Unrecognized input at Line %v Column %v %s", t.Line, t.Column, raw)
} | |
c20495 | len(l.stack) > 0 {
l.state = l.pop()
} else if l.state == nil {
return Token{T: TokenEOF, V: ""}
}
l.state = l.state(l)
}
}
} | |
c20496 | strings.Replace(l.input, "\n", " ", -1)
}
u.LogThrottle(u.WARN, 10, "Gracefully refusing to add more LexExpression: %s", out)
}
} | |
c20497 | l.Next()
l.backup()
return r
} | |
c20498 | return l.input[l.pos:]
}
return l.input[l.pos : l.pos+x]
} | |
c20499 | if ri != 1 {
skip += (ri - 1)
}
if !unicode.IsSpace(r) {
return r
}
}
return rune(0)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.