_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q20400 | DiffInMinutes | train | func (c *Carbon) DiffInMinutes(d *Carbon, abs bool) int64 {
return c.DiffInSeconds(d, abs) / secondsPerMinute
} | go | {
"resource": ""
} |
q20401 | DiffInSeconds | train | func (c *Carbon) DiffInSeconds(carb *Carbon, abs bool) int64 {
if carb == nil {
carb = nowIn(c.Location())
}
diff := carb.Timestamp() - c.Timestamp()
return absValue(abs, diff)
} | go | {
"resource": ""
} |
q20402 | SecondsSinceMidnight | train | func (c *Carbon) SecondsSinceMidnight() int {
startOfDay := c.StartOfDay()
return int(c.DiffInSeconds(startOfDay, true))
} | go | {
"resource": ""
} |
q20403 | absValue | train | func absValue(needsAbs bool, value int64) int64 {
if needsAbs && value < 0 {
return -value
}
return value
} | go | {
"resource": ""
} |
q20404 | Next | train | func (c *Carbon) Next(wd time.Weekday) *Carbon {
c = c.AddDay()
for c.Weekday() != wd {
c = c.AddDay()
}
return c.StartOfDay()
} | go | {
"resource": ""
} |
q20405 | NextWeekendDay | train | func (c *Carbon) NextWeekendDay() *Carbon {
c = c.AddDay()
for !c.IsWeekend() {
c = c.AddDay()
}
return c
} | go | {
"resource": ""
} |
q20406 | PreviousWeekendDay | train | func (c *Carbon) PreviousWeekendDay() *Carbon {
c = c.SubDay()
for !c.IsWeekend() {
c = c.SubDay()
}
return c
} | go | {
"resource": ""
} |
q20407 | Previous | train | func (c *Carbon) Previous(wd time.Weekday) *Carbon {
c = c.SubDay()
for c.Weekday() != wd {
c = c.SubDay()
}
return c.StartOfDay()
} | go | {
"resource": ""
} |
q20408 | FirstOfMonth | train | func (c *Carbon) FirstOfMonth(wd time.Weekday) *Carbon {
d := c.StartOfMonth()
if d.Weekday() != wd {
return d.Next(wd)
}
return d
} | go | {
"resource": ""
} |
q20409 | LastOfMonth | train | func (c *Carbon) LastOfMonth(wd time.Weekday) *Carbon {
d := c.EndOfMonth()
if d.Weekday() != wd {
return d.Previous(wd)
}
return d.StartOfDay()
} | go | {
"resource": ""
} |
q20410 | LastDayOfMonth | train | func (c *Carbon) LastDayOfMonth() *Carbon {
return NewCarbon(time.Date(c.Year(), c.Month(), c.DaysInMonth(), 0, 0, 0, 0, time.UTC))
} | go | {
"resource": ""
} |
q20411 | FirstDayOfMonth | train | func (c *Carbon) FirstDayOfMonth() *Carbon {
return NewCarbon(time.Date(c.Year(), c.Month(), 1, 0, 0, 0, 0, time.UTC))
} | go | {
"resource": ""
} |
q20412 | NthOfMonth | train | func (c *Carbon) NthOfMonth(nth int, wd time.Weekday) *Carbon {
cp := c.Copy().StartOfMonth()
i := 0
if cp.Weekday() == wd {
i++
}
for i < nth {
cp = cp.Next(wd)
i++
}
if cp.Gt(c.EndOfMonth()) {
return c
}
return cp
} | go | {
"resource": ""
} |
q20413 | FirstOfQuarter | train | func (c *Carbon) FirstOfQuarter(wd time.Weekday) *Carbon {
d := c.StartOfQuarter()
if d.Weekday() != wd {
return d.Next(wd)
}
return d
} | go | {
"resource": ""
} |
q20414 | LastOfQuarter | train | func (c *Carbon) LastOfQuarter(wd time.Weekday) *Carbon {
d := c.EndOfQuarter()
if d.Weekday() != wd {
return d.Previous(wd)
}
return d.StartOfDay()
} | go | {
"resource": ""
} |
q20415 | NthOfQuarter | train | func (c *Carbon) NthOfQuarter(nth int, wd time.Weekday) *Carbon {
cp := c.Copy().StartOfQuarter()
i := 0
if cp.Weekday() == wd {
i++
}
for i < nth {
cp = cp.Next(wd)
i++
}
if cp.Gt(c.EndOfQuarter()) {
return c
}
return cp
} | go | {
"resource": ""
} |
q20416 | FirstOfYear | train | func (c *Carbon) FirstOfYear(wd time.Weekday) *Carbon {
d := c.StartOfYear()
if d.Weekday() != wd {
return d.Next(wd)
}
return d
} | go | {
"resource": ""
} |
q20417 | LastOfYear | train | func (c *Carbon) LastOfYear(wd time.Weekday) *Carbon {
d := c.EndOfYear()
if d.Weekday() != wd {
return d.Previous(wd)
}
return d.StartOfDay()
} | go | {
"resource": ""
} |
q20418 | NthOfYear | train | func (c *Carbon) NthOfYear(nth int, wd time.Weekday) *Carbon {
cp := c.Copy().StartOfYear()
i := 0
if cp.Weekday() == wd {
i++
}
for i < nth {
cp = cp.Next(wd)
i++
}
if cp.Gt(c.EndOfYear()) {
return c
}
return cp
} | go | {
"resource": ""
} |
q20419 | Average | train | func (c *Carbon) Average(carb *Carbon) *Carbon {
if carb == nil {
carb = nowIn(c.Location())
}
if c.Eq(carb) {
return c.Copy()
}
average := int(c.DiffInSeconds(carb, false) / 2)
return c.AddSeconds(average)
} | go | {
"resource": ""
} |
q20420 | GetTranslator | train | func (c *Carbon) GetTranslator() (*Translator, error) {
if c.Translator == nil {
c.Translator = translator()
}
return c.Translator, nil
} | go | {
"resource": ""
} |
q20421 | SetLocale | train | func (c *Carbon) SetLocale(l string) error {
err := c.Translator.SetLocale(l)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q20422 | NewCarbonInterval | train | func NewCarbonInterval(start, end *Carbon) (*CarbonInterval, error) {
if start.Gte(end) {
return nil, errors.New("The end date must be greater than the start date.")
}
return &CarbonInterval{
Start: start,
End: end,
}, nil
} | go | {
"resource": ""
} |
q20423 | DiffInHours | train | func (ci *CarbonInterval) DiffInHours() int64 {
return ci.End.DiffInHours(ci.Start, true)
} | go | {
"resource": ""
} |
q20424 | SetLocale | train | func (t *Translator) SetLocale(l string) error {
err := t.AssertValidLocale(l)
if err != nil {
return err
}
err = t.loadResource(l)
if err != nil {
return err
}
t.locale = l
return nil
} | go | {
"resource": ""
} |
q20425 | AssertValidLocale | train | func (t *Translator) AssertValidLocale(l string) error {
matched, err := regexp.MatchString("^(?:[a-z]{2}|[a-z]{2}(([_-]{1})([a-zA-Z]{2}){1,2}))$", l)
if err != nil {
return errors.New("unable to match locale code : " + err.Error())
}
if !matched {
return errors.New("invalid locale code : " + l)
}
return nil... | go | {
"resource": ""
} |
q20426 | loadResource | train | func (t *Translator) loadResource(l string) error {
ltext, err := lang.LoadLocaleText(l)
if err != nil {
return err
}
err = json.Unmarshal(ltext, &t.resources)
if err != nil {
return errors.New("unable to unmarshall locale data : " + err.Error())
}
return nil
} | go | {
"resource": ""
} |
q20427 | chooseUnit | train | func (t *Translator) chooseUnit(unit string, count int64) (string, error) {
s := strings.Split(t.resources[unit], "|")
if count > 1 {
return strings.Replace(s[1], ":count", strconv.FormatInt(int64(count), 10), 1), nil
}
return s[0], nil
} | go | {
"resource": ""
} |
q20428 | chooseTrans | train | func (t *Translator) chooseTrans(transID, time string) string {
return strings.Replace(t.resources[transID], ":time", time, 1)
} | go | {
"resource": ""
} |
q20429 | LoadLocaleText | train | func LoadLocaleText(l string) ([]byte, error) {
lText, err := ioutil.ReadFile("./lang/" + l + ".json")
if err != nil {
return nil, errors.New("not able to read the lang file:" + err.Error())
}
return lText, nil
} | go | {
"resource": ""
} |
q20430 | New | train | func New(t T) *I {
return &I{t, t.FailNow, os.Stdout, !noColorFlag}
} | go | {
"resource": ""
} |
q20431 | NewRelaxed | train | func NewRelaxed(t T) *I {
return &I{t, t.Fail, os.Stdout, !noColorFlag}
} | go | {
"resource": ""
} |
q20432 | loadComment | train | func loadComment(path string, line int) (string, bool) {
f, err := os.Open(path)
if err != nil {
return "", false
}
defer f.Close()
s := bufio.NewScanner(f)
i := 1
for s.Scan() {
if i == line {
text := s.Text()
commentI := strings.Index(text, "//")
if commentI == -1 {
return "", false // no comm... | go | {
"resource": ""
} |
q20433 | loadArguments | train | func loadArguments(path string, line int) (string, bool) {
f, err := os.Open(path)
if err != nil {
return "", false
}
defer f.Close()
s := bufio.NewScanner(f)
i := 1
for s.Scan() {
if i == line {
text := s.Text()
braceI := strings.Index(text, "(")
if braceI == -1 {
return "", false
}
text ... | go | {
"resource": ""
} |
q20434 | decorate | train | func (is *I) decorate(s string) string {
path, lineNumber, ok := callerinfo() // decorate + log + public function.
file := filepath.Base(path)
if ok {
// Truncate file name at last file name separator.
if index := strings.LastIndex(file, "/"); index >= 0 {
file = file[index+1:]
} else if index = strings.Las... | go | {
"resource": ""
} |
q20435 | LexEndOfSubStatement | train | func LexEndOfSubStatement(l *Lexer) StateFn {
l.SkipWhiteSpaces()
if strings.ToLower(l.PeekX(2)) == "as" {
return nil
}
l.backup()
return l.errorToken("Unexpected token:" + l.current())
} | go | {
"resource": ""
} |
q20436 | LexLimit | train | func LexLimit(l *Lexer) StateFn {
l.SkipWhiteSpaces()
keyWord := strings.ToLower(l.PeekWord())
//u.Debugf("LexLimit r= '%v'", string(keyWord))
switch keyWord {
case "offset":
return nil
case "", ";":
return nil
case ",":
l.ConsumeWord(keyWord)
l.Emit(TokenComma)
return LexNumber
default:
if isDig... | go | {
"resource": ""
} |
q20437 | LexDdlTable | train | func LexDdlTable(l *Lexer) StateFn {
/*
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
(create_definition,...)
[table_options]
[partition_options]
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
[(create_definition,...)]
[table_options]
[partition_options]
[IGNORE |... | go | {
"resource": ""
} |
q20438 | Setup | train | func (m *Source) Setup(s *schema.Schema) error {
m.mu.Lock()
defer m.mu.Unlock()
u.Debugf("got new sqlite schema %s", s.Name)
m.schema = s
if m.db != nil {
return nil
}
m.file = s.Conf.Settings.String("file")
if m.file == "" {
m.file = fmt.Sprintf("/tmp/%s.sql.db", s.Name)
u.Warnf("using tmp? %q", m.fil... | go | {
"resource": ""
} |
q20439 | Open | train | func (m *Source) Open(table string) (schema.Conn, error) {
//u.Infof("Open conn=%q", table)
m.tblmu.Lock()
t, ok := m.tables[table]
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
} | go | {
"resource": ""
} |
q20440 | Table | train | func (m *Source) Table(table string) (*schema.Table, error) {
u.Infof("source.Table(%q)", table)
m.tblmu.Lock()
t, ok := m.tables[table]
m.tblmu.Unlock()
if !ok {
return nil, schema.ErrNotFound
}
return t, nil
} | go | {
"resource": ""
} |
q20441 | Close | train | func (m *Source) Close() error {
if m.db != nil {
err := m.db.Close()
if err != nil {
return err
}
m.db = nil
}
return nil
} | go | {
"resource": ""
} |
q20442 | errRecover | train | func errRecover(errp *error) {
e := recover()
if e != nil {
switch err := e.(type) {
case runtime.Error:
panic(e)
case error:
*errp = err
default:
panic(e)
}
}
} | go | {
"resource": ""
} |
q20443 | numberNodeToValue | train | func numberNodeToValue(t *expr.NumberNode) (value.Value, bool) {
if t.IsInt {
return value.NewIntValue(t.Int64), true
} else if t.IsFloat {
fv, ok := value.StringToFloat64(t.Text)
if !ok {
u.Debugf("Could not perform numeric conversion for %q", t.Text)
return value.NilValueVal, false
}
return value.Ne... | go | {
"resource": ""
} |
q20444 | ResolveIncludes | train | func ResolveIncludes(ctx expr.Includer, arg expr.Node) error {
return resolveIncludesDepth(ctx, arg, 0)
} | go | {
"resource": ""
} |
q20445 | walkTernary | train | func walkTernary(ctx expr.EvalContext, node *expr.TriNode, depth int) (value.Value, bool) {
a, aok := Eval(ctx, node.Args[0])
b, bok := Eval(ctx, node.Args[1])
c, cok := Eval(ctx, node.Args[2])
//u.Infof("tri: %T:%v %v %T:%v %T:%v", a, a, node.Operator, b, b, c, c)
if !aok {
return nil, false
}
if !bok |... | go | {
"resource": ""
} |
q20446 | walkFunc | train | func walkFunc(ctx expr.EvalContext, node *expr.FuncNode, depth int) (value.Value, bool) {
if node.F.CustomFunc == nil {
return nil, false
}
if node.Eval == nil {
u.LogThrottle(u.WARN, 10, "No Eval() for %s", node.Name)
return nil, false
}
args := make([]value.Value, len(node.Args))
for i, a := range node... | go | {
"resource": ""
} |
q20447 | LikeCompare | train | func LikeCompare(a, b string) (value.BoolValue, bool) {
// Do we want to always do this replacement? Or do this at parse time or config?
if strings.Contains(b, "%") {
b = strings.Replace(b, "%", "*", -1)
}
match, err := glob.Match(b, a)
if err != nil {
return value.BoolValueFalse, false
}
if match {
retu... | go | {
"resource": ""
} |
q20448 | UnmarshalJSON | train | func (m *JsonHelperScannable) UnmarshalJSON(data []byte) error {
if m == nil {
return errors.New("JsonHelperScannable must not be nil")
}
jh := make(u.JsonHelper)
if err := json.Unmarshal(data, &jh); err != nil {
return err
}
*m = JsonHelperScannable(jh)
return nil
} | go | {
"resource": ""
} |
q20449 | Value | train | func (m StringArray) Value() (driver.Value, error) {
by, err := json.Marshal(m)
return by, err
} | go | {
"resource": ""
} |
q20450 | InlineIncludes | train | func InlineIncludes(ctx Includer, n Node) (Node, error) {
return doInlineIncludes(ctx, n, 0)
} | go | {
"resource": ""
} |
q20451 | WalkStmt | train | func WalkStmt(ctx *Context, stmt rel.SqlStatement, planner Planner) (Task, error) {
var p Task
base := NewPlanBase(false)
switch st := stmt.(type) {
case *rel.SqlSelect:
p = &Select{Stmt: st, PlanBase: base, Ctx: ctx}
case *rel.SqlInsert:
p = &Insert{Stmt: st, PlanBase: base}
case *rel.SqlUpsert:
p = &Upser... | go | {
"resource": ""
} |
q20452 | SelectPlanFromPbBytes | train | func SelectPlanFromPbBytes(pb []byte, loader SchemaLoader) (*Select, error) {
p := &PlanPb{}
if err := proto.Unmarshal(pb, p); err != nil {
u.Errorf("error reading protobuf select: %v \n%s", err, pb)
return nil, err
}
switch {
case p.Select != nil:
return SelectFromPB(p, loader)
}
return nil, ErrNotImplem... | go | {
"resource": ""
} |
q20453 | SelectTaskFromTaskPb | train | func SelectTaskFromTaskPb(pb *PlanPb, ctx *Context, sel *rel.SqlSelect) (Task, error) {
switch {
case pb.Source != nil:
return SourceFromPB(pb, ctx)
case pb.Where != nil:
return WhereFromPB(pb), nil
case pb.Having != nil:
return HavingFromPB(pb), nil
case pb.GroupBy != nil:
return GroupByFromPB(pb), nil
c... | go | {
"resource": ""
} |
q20454 | NewCreate | train | func NewCreate(ctx *Context, stmt *rel.SqlCreate) *Create {
return &Create{Stmt: stmt, PlanBase: NewPlanBase(false), Ctx: ctx}
} | go | {
"resource": ""
} |
q20455 | NewDrop | train | func NewDrop(ctx *Context, stmt *rel.SqlDrop) *Drop {
return &Drop{Stmt: stmt, PlanBase: NewPlanBase(false), Ctx: ctx}
} | go | {
"resource": ""
} |
q20456 | NewAlter | train | func NewAlter(ctx *Context, stmt *rel.SqlAlter) *Alter {
return &Alter{Stmt: stmt, PlanBase: NewPlanBase(false), Ctx: ctx}
} | go | {
"resource": ""
} |
q20457 | NewSource | train | func NewSource(ctx *Context, stmt *rel.SqlSource, isFinal bool) (*Source, error) {
s := &Source{Stmt: stmt, ctx: ctx, SourcePb: &SourcePb{Final: isFinal}, PlanBase: NewPlanBase(false)}
err := s.load()
if err != nil {
return nil, err
}
return s, nil
} | go | {
"resource": ""
} |
q20458 | Equal | train | func (m *Projection) Equal(t Task) bool {
if m == nil && t == nil {
return true
}
if m == nil && t != nil {
return false
}
if m != nil && t == nil {
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
}
... | go | {
"resource": ""
} |
q20459 | ToPb | train | func (m *Projection) ToPb() (*PlanPb, error) {
pbp, err := m.PlanBase.ToPb()
if err != nil {
return nil, err
}
ppbptr := m.Proj.ToPB()
ppcpy := *ppbptr
ppcpy.Final = m.Final
pbp.Projection = &ppcpy
return pbp, nil
} | go | {
"resource": ""
} |
q20460 | ProjectionFromPB | train | func ProjectionFromPB(pb *PlanPb, sel *rel.SqlSelect) *Projection {
m := Projection{
Proj: rel.ProjectionFromPb(pb.Projection),
}
m.Final = pb.Projection.Final
m.PlanBase = NewPlanBase(pb.Parallel)
m.Stmt = sel
return &m
} | go | {
"resource": ""
} |
q20461 | NewJoinKey | train | func NewJoinKey(s *Source) *JoinKey {
return &JoinKey{Source: s, PlanBase: NewPlanBase(false)}
} | go | {
"resource": ""
} |
q20462 | NewWhere | train | func NewWhere(stmt *rel.SqlSelect) *Where {
return &Where{Stmt: stmt, PlanBase: NewPlanBase(false)}
} | go | {
"resource": ""
} |
q20463 | NewWhereFinal | train | func NewWhereFinal(stmt *rel.SqlSelect) *Where {
return &Where{Stmt: stmt, Final: true, PlanBase: NewPlanBase(false)}
} | go | {
"resource": ""
} |
q20464 | NewHaving | train | func NewHaving(stmt *rel.SqlSelect) *Having {
return &Having{Stmt: stmt, PlanBase: NewPlanBase(false)}
} | go | {
"resource": ""
} |
q20465 | NewGroupBy | train | func NewGroupBy(stmt *rel.SqlSelect) *GroupBy {
return &GroupBy{Stmt: stmt, PlanBase: NewPlanBase(false)}
} | go | {
"resource": ""
} |
q20466 | NewOrder | train | func NewOrder(stmt *rel.SqlSelect) *Order {
return &Order{Stmt: stmt, PlanBase: NewPlanBase(false)}
} | go | {
"resource": ""
} |
q20467 | Equal | train | func (m *Into) Equal(t Task) bool {
if m == nil && t == nil {
return true
}
if m == nil && t != nil {
return false
}
if m != nil && t == nil {
return false
}
s, ok := t.(*Into)
if !ok {
return false
}
if !m.PlanBase.EqualBase(s.PlanBase) {
return false
}
return true
} | go | {
"resource": ""
} |
q20468 | rewrite | train | func (m *rewrite) rewrite() (string, error) {
var err error
if m.sel.Where != nil {
m.result.Where = m.sel.Where
m.result.Where.Expr, err = m.walkNode(m.sel.Where.Expr)
if err != nil {
return "", err
}
}
// Evaluate the Select columns make sure we can pass them down or polyfill
err = m.walkSelectList... | go | {
"resource": ""
} |
q20469 | RewriteSelect | train | func RewriteSelect(m *SqlSelect) {
originalCols := m.Columns
m.Columns = make(Columns, 0, len(originalCols)+5)
rewriteIntoProjection(m, originalCols)
rewriteIntoProjection(m, m.GroupBy)
if m.Where != nil {
colsToAdd := expr.FindAllIdentityField(m.Where.Expr)
addIntoProjection(m, colsToAdd)
}
rewriteIntoProje... | go | {
"resource": ""
} |
q20470 | RewriteSqlSource | train | func RewriteSqlSource(m *SqlSource, parentStmt *SqlSelect) *SqlSelect {
if m.Source != nil {
return m.Source
}
// Rewrite this SqlSource for the given parent, ie
// 1) find the column names we need to request from source including those used in join/where
// 2) rewrite the where for this partial query
//... | go | {
"resource": ""
} |
q20471 | rewriteNode | train | func rewriteNode(from *SqlSource, node expr.Node) expr.Node {
switch nt := node.(type) {
case *expr.IdentityNode:
if left, right, ok := nt.LeftRight(); ok {
//u.Debugf("rewriteNode from.Name:%v l:%v r:%v", from.alias, left, right)
if left == from.alias {
in := expr.IdentityNode{Text: right}
//u.Warnf... | go | {
"resource": ""
} |
q20472 | FiltersFromArgs | train | func FiltersFromArgs(filterVals []value.Value) []string {
filters := make([]string, 0, len(filterVals))
for _, fv := range filterVals {
switch fv := fv.(type) {
case value.Slice:
for _, fv := range fv.SliceValue() {
matchKey := fv.ToString()
if strings.Contains(matchKey, "%") {
matchKey = strings.... | go | {
"resource": ""
} |
q20473 | scalar | train | func scalar(node expr.Node) (interface{}, bool) {
switch n := node.(type) {
case *expr.StringNode:
return n.Text, true
case *expr.NumberNode:
if n.IsInt {
// ES supports string encoded ints
return n.Int64, true
}
return n.Float64, true
case *expr.ValueNode:
// Make sure this is a scalar value nod... | go | {
"resource": ""
} |
q20474 | Eval | train | func (m *defaultTypeWriter) Eval(ctx expr.EvalContext, vals []value.Value) (value.Value, bool) {
if len(vals) == 0 || vals[0] == nil || vals[0].Nil() {
return nil, false
}
switch sv := vals[0].(type) {
case value.StringValue:
return sv, true
}
return value.NewStringValue(""), false
} | go | {
"resource": ""
} |
q20475 | Drop | train | func (m *InMemApplyer) Drop(s *Schema, v interface{}) error {
// Find the type of operation being updated.
switch v := v.(type) {
case *Table:
u.Debugf("%p:%s InfoSchema P:%p dropping table %q from %v", s, s.Name, s.InfoSchema, v.Name, s.Tables())
// s==v means schema is being dropped
m.reg.mu.Lock()
s.mu.... | go | {
"resource": ""
} |
q20476 | NewCsvSource | train | func NewCsvSource(table string, indexCol int, ior io.Reader, exit <-chan bool) (*CsvDataSource, error) {
m := CsvDataSource{table: table, indexCol: indexCol}
if rc, ok := ior.(io.ReadCloser); ok {
m.rc = rc
}
buf := bufio.NewReader(ior)
first2, err := buf.Peek(2)
if err != nil {
u.Errorf("Error opening buf... | go | {
"resource": ""
} |
q20477 | NewMemDbData | train | func NewMemDbData(name string, data [][]driver.Value, cols []string) (*MemDb, error) {
m, err := NewMemDb(name, cols)
if err != nil {
return nil, err
}
// Insert initial values
conn := newDbConn(m)
defer conn.Close()
for _, row := range data {
conn.Put(nil, nil, row)
}
// we are going to look at ~10 rows... | go | {
"resource": ""
} |
q20478 | NewMemDb | train | func NewMemDb(name string, cols []string) (*MemDb, error) {
return NewMemDbForSchema(name, cols)
} | go | {
"resource": ""
} |
q20479 | NewMemDbForSchema | train | func NewMemDbForSchema(name string, cols []string) (*MemDb, error) {
if len(cols) < 1 {
return nil, fmt.Errorf("must have columns provided")
}
m := &MemDb{}
m.exit = make(chan bool, 1)
var err error
m.tbl = schema.NewTable(name)
m.tbl.SetColumns(cols)
m.buildDefaultIndexes()
mdbSchema := makeMemDbSchema(m)
... | go | {
"resource": ""
} |
q20480 | DeleteExpression | train | func (m *dbConn) DeleteExpression(p interface{}, where expr.Node) (int, error) {
var deletedKeys []schema.Key
txn := m.db.Txn(true)
iter, err := txn.Get(m.md.tbl.Name, m.md.primaryIndex)
if err != nil {
txn.Abort()
u.Errorf("could not get values %v", err)
return 0, err
}
deleteLoop:
for {
item := iter.Ne... | go | {
"resource": ""
} |
q20481 | ValueFromString | train | func ValueFromString(vt string) ValueType {
switch vt {
case "nil", "null":
return NilType
case "error":
return ErrorType
case "unknown":
return UnknownType
case "value":
return ValueInterfaceType
case "number":
return NumberType
case "int":
return IntType
case "bool":
return BoolType
case "time"... | go | {
"resource": ""
} |
q20482 | FindAllIdentities | train | func FindAllIdentities(node Node) IdentityNodes {
in := make(IdentityNodes, 0)
return findIdentities(node, in)
} | go | {
"resource": ""
} |
q20483 | Strings | train | func (m IdentityNodes) Strings() []string {
s := make([]string, len(m))
for i, in := range m {
s[i] = in.Text
}
return s
} | go | {
"resource": ""
} |
q20484 | LeftStrings | train | func (m IdentityNodes) LeftStrings() []string {
s := make([]string, len(m))
for i, in := range m {
l, r, hasLr := in.LeftRight()
if hasLr {
s[i] = l
} else {
s[i] = r
}
}
return s
} | go | {
"resource": ""
} |
q20485 | ValueTypeFromNode | train | func ValueTypeFromNode(n Node) value.ValueType {
switch nt := n.(type) {
case *FuncNode:
if nt == nil {
return value.UnknownType
}
if nt.F.CustomFunc == nil {
return value.UnknownType
}
return nt.F.Type()
case *StringNode:
return value.StringType
case *IdentityNode:
// Identity types will draw t... | go | {
"resource": ""
} |
q20486 | NewFuncNode | train | func NewFuncNode(name string, f Func) *FuncNode {
return &FuncNode{Name: name, F: f}
} | go | {
"resource": ""
} |
q20487 | Expr | train | func (m *FuncNode) Expr() *Expr {
fe := &Expr{Op: lex.TokenUdfExpr.String()}
if len(m.Args) > 0 {
fe.Args = []*Expr{{Identity: m.Name}}
fe.Args = append(fe.Args, ExprsFromNodes(m.Args)...)
}
return fe
} | go | {
"resource": ""
} |
q20488 | NewNumberStr | train | func NewNumberStr(text string) (*NumberNode, error) {
n := &NumberNode{Text: text}
return n, n.load()
} | go | {
"resource": ""
} |
q20489 | NewBooleanNode | train | func NewBooleanNode(operator lex.Token, args ...Node) *BooleanNode {
//u.Debugf("NewBinaryNode: %v %v %v", lhArg, operator, rhArg)
return &BooleanNode{Args: args, Operator: operator}
} | go | {
"resource": ""
} |
q20490 | NewTriNode | train | func NewTriNode(operator lex.Token, arg1, arg2, arg3 Node) *TriNode {
return &TriNode{Args: []Node{arg1, arg2, arg3}, Operator: operator}
} | go | {
"resource": ""
} |
q20491 | NodeFromPb | train | func NodeFromPb(pb []byte) (Node, error) {
n := &NodePb{}
if err := proto.Unmarshal(pb, n); err != nil {
return nil, err
}
return NodeFromNodePb(n), nil
} | go | {
"resource": ""
} |
q20492 | NodeFromNodePb | train | func NodeFromNodePb(n *NodePb) Node {
if n == nil {
return nil
}
switch {
case n.Bn != nil:
var bn *BinaryNode
return bn.FromPB(n)
case n.Booln != nil:
var bn *BooleanNode
return bn.FromPB(n)
case n.Un != nil:
var un *UnaryNode
return un.FromPB(n)
case n.Fn != nil:
var fn *FuncNode
return fn.Fr... | go | {
"resource": ""
} |
q20493 | NewLexer | train | func NewLexer(input string, dialect *Dialect) *Lexer {
// Three tokens of buffering is sufficient for all state functions.
l := &Lexer{
input: input,
state: LexDialectForStatement,
tokens: make(chan Token, 3),
stack: make([]NamedStateFn, 0, 10),
dialect: dialect,
}
if len(dialect.IdentityQuoting) >... | go | {
"resource": ""
} |
q20494 | ErrMsg | train | func (l *Lexer) ErrMsg(t Token, msg string) error {
raw := l.RawInput()
if len(raw) == l.pos {
raw = ""
} else if len(raw) > t.Pos {
if t.Pos > 0 {
raw = raw[t.Pos-1:]
} else {
raw = raw[t.Pos:]
}
if len(raw) > 20 {
raw = raw[:19]
}
} else {
raw = ""
}
if len(msg) > 0 {
return fmt.Errorf... | go | {
"resource": ""
} |
q20495 | NextToken | train | func (l *Lexer) NextToken() Token {
for {
//u.Debugf("token: start=%v pos=%v peek5=%s", l.start, l.pos, l.PeekX(5))
select {
case token := <-l.tokens:
return token
default:
if l.state == nil && len(l.stack) > 0 {
l.state = l.pop()
} else if l.state == nil {
return Token{T: TokenEOF, V: ""}
... | go | {
"resource": ""
} |
q20496 | Push | train | func (l *Lexer) Push(name string, state StateFn) {
debugf("push %d %v", len(l.stack)+1, name)
if len(l.stack) < 500 {
l.stack = append(l.stack, NamedStateFn{name, state})
} else {
out := ""
if len(l.input) > 200 {
out = strings.Replace(l.input[0:199], "\n", " ", -1)
} else {
out = strings.Replace(l.inp... | go | {
"resource": ""
} |
q20497 | Peek | train | func (l *Lexer) Peek() rune {
r := l.Next()
l.backup()
return r
} | go | {
"resource": ""
} |
q20498 | PeekX | train | func (l *Lexer) PeekX(x int) string {
if l.pos+x > len(l.input) {
return l.input[l.pos:]
}
return l.input[l.pos : l.pos+x]
} | go | {
"resource": ""
} |
q20499 | peekRunePast | train | func (l *Lexer) peekRunePast(skip int) rune {
if l.pos+skip+1 > len(l.input) {
return rune(0)
}
for ; skip < len(l.input)-l.pos; skip++ {
r, ri := utf8.DecodeRuneInString(l.input[l.pos+skip:])
if ri != 1 {
skip += (ri - 1)
}
if !unicode.IsSpace(r) {
return r
}
}
return rune(0)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.