id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c20600 | l:%v r:%v ok?%v", left, right, ok)
if ok {
cols[right] = idx
} else {
cols[left] = idx
}
}
m.colIndex = cols
return m.colIndex
} | |
c20601 | {
return nil, err
}
return statementFromPb(s), nil
} | |
c20602 | return false
}
case u.JsonHelper:
rh, isHelper := rv.(u.JsonHelper)
if !isHelper {
return false
}
if !EqualWith(lvt, rh) {
return false
}
case map[string]interface{}:
rh, isHelper := rv.(u.JsonHelper)
if !isHelper {
return false
}
if !EqualWith(u.JsonHelper(lvt), rh) {
... | |
c20603 | {
e := &JobExecutor{}
e.Executor = e
e.Planner = planner
e.Ctx = ctx
return e
} | |
c20604 | case *plan.Command:
return m.Executor.WalkCommand(p)
// DDL
case *plan.Create:
return m.Executor.WalkCreate(p)
case *plan.Drop:
return m.Executor.WalkDrop(p)
case *plan.Alter:
return m.Executor.WalkAlter(p)
}
panic(fmt.Sprintf("Not implemented for %T", p))
} | |
c20605 | error) {
root := m.NewTask(p)
return root, m.WalkChildren(p, root)
} | |
c20606 | error) {
root := m.NewTask(p)
return root, root.Add(NewCommand(m.Ctx, p))
} | |
c20607 | error) {
root := m.NewTask(p)
return root, root.Add(NewCreate(m.Ctx, p))
} | |
c20608 | error) {
root := m.NewTask(p)
return root, root.Add(NewDrop(m.Ctx, p))
} | |
c20609 | error) {
root := m.NewTask(p)
return root, root.Add(NewAlter(m.Ctx, p))
} | |
c20610 | for _, c := range t.Children() {
ct, err := m.WalkPlanTask(c)
if err != nil {
u.Errorf("could not create child task %#v err=%v", c, err)
return err
}
if err = childRoot.Add(ct); err != nil {
u.Errorf("Could not add task %v", err)
return err
}
}
}
}
return nil
} | |
c20611 | {
return fmt.Errorf("No task exists for this job")
}
return m.RootTask.Setup(0)
} | |
c20612 | tasks[len(tasks)-1].(TaskRunner).MessageOut()
} | |
c20613 | if err != nil {
return value.EmptyStringValue, false
}
if len(args) == 1 {
return value.NewStringValue(fmt.Sprintf("%s%s", up.Host, up.Path)), true
}
oldvals := up.Query()
newvals := make(url.Values)
for k, v := range oldvals {
// include fields specified as arguments
for _, pattern := range... | |
c20614 | NewSchemaDb(s)
s.InfoSchema.DS = schemaDb
return schemaDb
} | |
c20615 | s,
tbls: defaultSchemaTables,
tableMap: make(map[string]*schema.Table),
}
return &m
} | |
c20616 | "indexes", "keys":
return m.tableForIndexes()
case "status":
return m.tableForVariables(table)
case "columns":
return m.tableForTable(table)
default:
return m.tableForTable(table)
}
} | |
c20617 |
m.rows = RowsForSession(ctx)
}
} | |
c20618 |
fmt.Fprint(w, "\n) ENGINE=InnoDB DEFAULT CHARSET=utf8;")
//tblStr := fmt.Sprintf("CREATE TABLE `%s` (\n\n);", tbl.Name, strings.Join(cols, ","))
//return tblStr, nil
return w.String()
} | |
c20619 |
children: make([]Task, 0),
}
p.Planner = p
return p
} | |
c20620 | error {
u.Debugf("WalkCommand %+v", p.Stmt)
return nil
} | |
c20621 | error {
u.Debugf("WalkDrop %+v", p.Stmt)
return nil
} | |
c20622 | return fmt.Errorf("CREATE {SCHEMA|SOURCE|DATABASE}")
}
return nil
} | |
c20623 | error {
u.Debugf("WalkAlter %#v", p)
return nil
} | |
c20624 | Line:%d Col:%d Q:%s Pos:%d}`,
t.V, t.T.String(), t.Line, t.Column, string(t.Quote), t.Pos)
} | |
c20625 | parts := strings.Split(ti.Kw, " ")
ti.firstWord = parts[0]
ti.HasSpaces = true
}
}
} | |
c20626 | V: op}
}
return Token{T: TokenNil}
} | |
c20627 | TokenNameMap[typ]
if ok {
return s.Kw
}
return "not implemented"
} | |
c20628 |
if tokInfo.HasSpaces {
return tokInfo.firstWord
}
return tokInfo.Kw
}
return "not implemented"
} | |
c20629 | := TokenNameMap[typ]
if ok {
return tokInfo.HasSpaces
}
return false
} | |
c20630 | return nil, fmt.Errorf("unknown schema %q", schemaName)
}
return schema.OpenConn(table)
} | |
c20631 |
registry.addSourceType(sourceType, source)
} | |
c20632 |
s := NewSchemaSource(name, source)
source.Init()
source.Setup(s)
if err := registry.SchemaAdd(s); err != nil {
return err
}
return discoverSchemaFromSource(s, registry.applyer)
} | |
c20633 | registryMu.Unlock()
return registry.SchemaAdd(schema)
} | |
c20634 | sources: make(map[string]Source),
schemas: make(map[string]*Schema),
schemaNames: make([]string, 0),
}
} | |
c20635 | return ErrNotFound
}
t, _ := s.Table(name)
if t == nil {
return ErrNotFound
}
return m.applyer.Drop(s, t)
}
return fmt.Errorf("Object type %s not recognized to DROP", objectType)
} | |
c20636 | return ErrNotFound
}
return m.applyer.AddOrUpdateOnSchema(s, s)
} | |
c20637 | != s.Name {
_, ok := m.Schema(conf.Schema)
if !ok {
ps := NewSchema(conf.Schema)
err := m.SchemaAdd(ps)
if err != nil {
u.Warnf("could not create parent schema %v", err)
return err
}
}
if err = m.SchemaAddChild(conf.Schema, s); err != nil {
return nil
}
return nil
}
return m.Schem... | |
c20638 | {
m.mu.RLock()
defer m.mu.RUnlock()
s, ok := m.schemas[schemaName]
return s, ok
} | |
c20639 | duplicate schema %q", s.Name)
}
if s.InfoSchema == nil {
s.InfoSchema = NewInfoSchema("schema", s)
}
m.applyer.AddOrUpdateOnSchema(s, s)
return nil
} | |
c20640 |
return fmt.Errorf("Cannot find schema %q to add child", name)
}
m.applyer.AddOrUpdateOnSchema(parent, child)
return nil
} | |
c20641 | return m.getDepth(0, sourceType)
} | |
c20642 | schemas = append(schemas, sch.Name)
}
return fmt.Sprintf("{Sources: [%s] , Schemas: [%s]}", strings.Join(sourceNames, ", "), strings.Join(schemas, ", "))
} | |
c20643 | for _, tableName := range s.Tables() {
tbl, err := s.Table(tableName)
if err != nil || tbl == nil {
u.Warnf("Missing table?? %q", tableName)
continue
}
applyer.AddOrUpdateOnSchema(s, tbl)
}
return nil
} | |
c20644 | expr.NewJSONDialectWriter()
m.WriteDialect(w)
return w.String()
} | |
c20645 | {
m.includes = expr.FindIncludes(m.Filter)
m.checkedIncludes = true
}
return m.includes
} | |
c20646 | return ""
}
w := expr.NewDefaultWriter()
m.WriteDialect(w)
return w.String()
} | |
c20647 | return false
}
mfs := m.FilterStatement
if mfs != nil {
sfs := s.FilterStatement
if !mfs.Equal(sfs) {
return false
}
}
return true
} | |
c20648 | if err := m.rows.Close(); err != nil {
return err
}
}
return nil
} | |
c20649 | if err := row.Scan(&vals); err != nil {
return nil, err
}
return datasource.NewSqlDriverMessageMap(0, vals, m.colidx), nil
} | |
c20650 | return -1, schema.ErrNotImplemented
} | |
c20651 | %s", sqlSelect.String())
u.Infof("pushdown sql: %s", sqlString)
rows, err := m.source.db.Query(sqlString)
if err != nil {
u.Errorf("could not open master err=%v", err)
return nil, err
}
m.rows = rows
m.TaskBase = exec.NewTaskBase(p.Context())
p.SourceExec = true
m.ps = p
//p.Complete = true
return nil, ... | |
c20652 | true
m.Unlock()
go m.drain()
//return m.TaskBase.Close()
return nil
} | |
c20653 | u.Warnf("error on close %v", r)
}
}()
//return nil
return m.TaskBase.Close()
} | |
c20654 | limit:%v", m, rowCt, limit)
out <- nil // Sending nil message is a message to downstream to shutdown
//m.Close()
m.Quit()
}
rowCt++
//return false
return true // swallow it
}
rowCt++
select {
case out <- msg:
return true
case <-m.SigChan():
return false
}
}
} | |
c20655 |
is.InfoSchema = is
is.SchemaRef = s
return is
} | |
c20656 | make(map[string]*Schema),
tableMap: make(map[string]*Table),
tableSchemas: make(map[string]*Schema),
tableNames: make([]string, 0),
DS: ds,
}
return m
} | |
c20657 | m.lastRefreshed.After(time.Now().Add(dur)) {
return true
}
return false
} | |
c20658 | m.tableMap[tableName]
if ok && tbl != nil {
return tbl, nil
}
}
if m.SchemaRef != nil {
return m.SchemaRef.Table(tableIn)
}
return nil, fmt.Errorf("Could not find that table: %v", tableIn)
} | |
c20659 | }
conn, err := sch.DS.Open(tableName)
if err != nil {
return nil, err
}
if conn == nil {
return nil, fmt.Errorf("Could not establish a connection for %v", tableName)
}
return conn, nil
} | |
c20660 | nil {
return child, nil
}
return nil, fmt.Errorf("Could not find a Schema by that name %q", schemaName)
} | |
c20661 | ss != nil && ss.DS != nil {
return ss, nil
}
u.Warnf("%p schema.SchemaForTable: no source!!!! schema=%q table=%q", m, m.Name, tableName)
return nil, ErrNotFound
} | |
c20662 | tableName, tbl := range child.tableMap {
m.tableSchemas[tableName] = child
m.tableMap[tableName] = tbl
}
} | |
c20663 |
}
t := &Table{
TablePb: tpb,
Fields: make([]*Field, 0),
FieldMap: make(map[string]*Field),
}
t.init(nil)
return t
} | |
c20664 | f := range m.Fields {
msgs[i] = f
}
return msgs
} | |
c20665 | }
}
if !found {
fld.idx = uint64(len(m.Fields))
m.Fields = append(m.Fields, fld)
}
m.FieldMap[fld.Name] = fld
} | |
c20666 | {
m.AddField(&Field{FieldPb: FieldPb{Type: uint32(valType), Name: name}})
} | |
c20667 |
if ok {
return f.ValueType(), true
}
return value.UnknownType, false
} | |
c20668 | //col = strings.ToLower(col)
m.FieldPositions[col] = idx
cols[idx] = col
}
m.cols = cols
} | |
c20669 |
col := strings.ToLower(f.Name)
m.FieldPositions[col] = idx
cols[idx] = col
}
m.cols = cols
} | |
c20670 | err != nil {
u.Errorf("Could not read schema %v", err)
return nil
}
sch, _ = schema.DefaultRegistry().Schema(SchemaName)
return sch
} | |
c20671 | schema.DefaultRegistry().SchemaRefresh(SchemaName)
} | |
c20672 | make(map[string]*membtree.StaticDataSource),
}
} | |
c20673 | error {
m.s = s
return nil
} | |
c20674 | {
names = append(names, tableName)
}
m.tablenamelist = names
return nil
} | |
c20675 | load table %q err=%v", tableName, err)
return nil, err
}
ds := m.tables[tableName]
return &Table{StaticDataSource: ds}, nil
} | |
c20676 | !exists {
m.tablenamelist = append(m.tablenamelist, tableName)
}
m.raw[tableName] = csvRaw
m.loadTable(tableName)
} | |
c20677 | m.partitionCt = uint64(m.ss.Conf.PartitionCt)
m.partitionFunc = SipPartitioner
return nil
} | |
c20678 |
return m.fdb.Open(tableName)
}
pg, err := m.createPager(tableName, 0, 0)
if err != nil {
u.Errorf("could not get pager: %v", err)
return nil, err
}
return pg, nil
} | |
c20679 | return nil, err
}
} else {
// Source doesn't implement Schema Handling so we are going to get
// a scanner and introspect some rows
t, err = m.buildTable(tableName)
if err != nil {
return nil, err
}
}
if t == nil {
return nil, fmt.Errorf("Missing table for %q", tableName)
}
m.tableSchemas... | |
c20680 |
//
switch valT := n.Args[1].(type) {
case *expr.NumberNode:
return NewKeyCol(in.Text, valT.Float64)
case *expr.StringNode:
return NewKeyCol(in.Text, valT.Text)
//case *expr.FuncNode:
default:
u.Warnf("not supported arg? %#v", valT)
}
default:
u.Warnf("not supported node type? %#v", n)
}
ret... | |
c20681 | v
case *expr.SqlInsert:
m.Keyword = lex.TokenInsert
m.ins = v
case *expr.SqlDelete:
m.Keyword = lex.TokenDelete
m.del = v
}
return m, nil
} | |
c20682 | return fmt.Errorf("Must implement RowWriter: %T", writeContext)
}
case lex.TokenDelete:
return m.ExecuteDelete(writeContext, readContext)
default:
u.Warnf("not implemented: %v", m.Keyword)
return fmt.Errorf("not implemented %v", m.Keyword)
}
return nil
} | |
c20683 | guard
}
if col.Star {
for k, v := range readContext.Row() {
writeContext.Put(&expr.Column{As: k}, nil, v)
}
} else {
//u.Debugf("tree.Root: as?%v %#v", col.As, col.Tree.Root)
v, ok := s.Walk(col.Tree.Root)
if ok {
writeContext.Put(col, readContext, v)
}
}
}
//writeContext.Put()
r... | |
c20684 | p,
complete: make(chan bool),
}
return o
} | |
c20685 | case '"':
return lex.LexValue(l)
case '/':
// a regex
return lex.LexRegex(l)
}
return lex.LexIdentifier
} | |
c20686 | conf")
}
fileStoreMu.Lock()
storeType = strings.ToLower(storeType)
fs, ok := fileStores[storeType]
fileStoreMu.Unlock()
if !ok {
return nil, fmt.Errorf("Unrecognized filestore type %q expected [gcs,localfs]", storeType)
}
return fs(ss)
} | |
c20687 | register: %v %T FileStore:%p", storeType, fs, fs)
fileStoreMu.Lock()
defer fileStoreMu.Unlock()
if _, dupe := fileStores[storeType]; dupe {
panic("Register called twice for FileStore type " + storeType)
}
fileStores[storeType] = fs
} | |
c20688 | u.Errorf("Could not find table %q", name)
return err
}
return IntrospectTable(tbl, iter)
} | |
c20689 | stmt.(*SqlSelect)
if !ok {
return nil, fmt.Errorf("Expected SqlSelect but got %T", stmt)
}
return sel, nil
} | |
c20690 | stmt, err := m.parse()
if err != nil {
return nil, &ParseError{err}
}
stmts = append(stmts, stmt)
sqlRemaining, hasMore := l.Remainder()
if !hasMore {
break
}
l = lex.NewSqlLexer(sqlRemaining)
m = Sqlbridge{l: l, SqlTokenPager: NewSqlTokenPager(l)}
}
return stmts, nil
} | |
c20691 | err != nil {
return nil, err
}
if len(sel.From) == 0 {
return nil, m.ErrMsg("Expected FROM <sources>")
}
req.Select = sel
return req, nil
default:
return nil, m.ErrMsg("expected INSERT (columns) VALUES <values>")
}
colVals, err := m.parseValueList()
if err != nil {
return nil, err
}
req.Rows... | |
c20692 | list of name=value pairs
m.Next()
cols, err := m.parseUpdateList()
if err != nil {
u.Error(err)
return nil, err
}
req.Values = cols
// WHERE
req.Where, err = m.parseWhere()
if err != nil {
return nil, err
}
return req, nil
} | |
c20693 |
switch m.Cur().T {
case lex.TokenValues:
m.Next() // Consume Values keyword
default:
return nil, m.ErrMsg("expected values")
}
//u.Debugf("found ? %v", m.Cur())
colVals, err := m.parseValueList()
if err != nil {
u.Error(err)
return nil, err
}
req.Rows = colVals
default:
return nil, m... | |
c20694 | name")
}
}
m.Next()
//u.Debugf("cur lex.Token: %s", m.Cur().T.String())
if errreq := m.parseWhereDelete(req); errreq != nil {
return nil, errreq
}
// we are good
return req, nil
} | |
c20695 | m.Next()
if m.Cur().T != lex.TokenValue {
return nil, m.ErrMsg("expected statement value ")
}
stmt, err := ParseSql(m.Cur().V)
if err != nil {
return nil, err
}
req.Statement = stmt
// we are good
return req, nil
} | |
c20696 | "extended":
sqlText := strings.Replace(m.l.RawInput(), req.Tok.V, "", 1)
sqlText = strings.Replace(sqlText, m.Cur().V, "", 1)
sqlSel, err := ParseSql(sqlText)
if err != nil {
return nil, err
}
req.Stmt = sqlSel
return req, nil
default:
if lex.TokenIdentity == m.Cur().T {
req.Identity = m.Cur().V... | |
c20697 | return req, nil
case cur.T == lex.TokenIdentity && strings.ToLower(cur.V) == "character" && strings.ToLower(peek.V) == "set":
m.Next() // consume character
m.Next() // consume set
col := &CommandColumn{Name: fmt.Sprintf("character set %s", m.Next().V)}
req.Columns = append(req.Columns, col)
return req, nil... | |
c20698 | = m.Next().V
default:
return nil, m.ErrMsg("Expected identity after DROP (TABLE|VIEW|SOURCE|SCHEMA|DATABASE) ")
}
switch req.Tok.T {
case lex.TokenTable:
// just table
case lex.TokenSource, lex.TokenSchema:
// schema
case lex.TokenContinuousView, lex.TokenView:
// view
default:
// triggers, index, e... | |
c20699 | len(vals))
for i, v := range vals {
msgs[i] = v.(schema.Message)
}
return msgs
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.