id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
20,600
|
araddon/qlbridge
|
rel/sql.go
|
ColumnPositions
|
func (m *SqlSource) ColumnPositions() map[string]int {
if len(m.colIndex) > 0 {
return m.colIndex
}
if m.Source == nil {
return nil
}
cols := make(map[string]int)
for idx, col := range m.Source.Columns {
left, right, ok := col.LeftRight()
//u.Debugf("aliasing: l:%v r:%v ok?%v", left, right, ok)
if ok {
cols[right] = idx
} else {
cols[left] = idx
}
}
m.colIndex = cols
return m.colIndex
}
|
go
|
func (m *SqlSource) ColumnPositions() map[string]int {
if len(m.colIndex) > 0 {
return m.colIndex
}
if m.Source == nil {
return nil
}
cols := make(map[string]int)
for idx, col := range m.Source.Columns {
left, right, ok := col.LeftRight()
//u.Debugf("aliasing: l:%v r:%v ok?%v", left, right, ok)
if ok {
cols[right] = idx
} else {
cols[left] = idx
}
}
m.colIndex = cols
return m.colIndex
}
|
[
"func",
"(",
"m",
"*",
"SqlSource",
")",
"ColumnPositions",
"(",
")",
"map",
"[",
"string",
"]",
"int",
"{",
"if",
"len",
"(",
"m",
".",
"colIndex",
")",
">",
"0",
"{",
"return",
"m",
".",
"colIndex",
"\n",
"}",
"\n",
"if",
"m",
".",
"Source",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"cols",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
")",
"\n",
"for",
"idx",
",",
"col",
":=",
"range",
"m",
".",
"Source",
".",
"Columns",
"{",
"left",
",",
"right",
",",
"ok",
":=",
"col",
".",
"LeftRight",
"(",
")",
"\n",
"//u.Debugf(\"aliasing: l:%v r:%v ok?%v\", left, right, ok)",
"if",
"ok",
"{",
"cols",
"[",
"right",
"]",
"=",
"idx",
"\n",
"}",
"else",
"{",
"cols",
"[",
"left",
"]",
"=",
"idx",
"\n",
"}",
"\n",
"}",
"\n",
"m",
".",
"colIndex",
"=",
"cols",
"\n",
"return",
"m",
".",
"colIndex",
"\n",
"}"
] |
// Get a list of Column names to position
|
[
"Get",
"a",
"list",
"of",
"Column",
"names",
"to",
"position"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/sql.go#L1478-L1497
|
20,601
|
araddon/qlbridge
|
rel/sql.go
|
SqlFromPb
|
func SqlFromPb(pb []byte) (SqlStatement, error) {
s := &SqlStatementPb{}
if err := proto.Unmarshal(pb, s); err != nil {
return nil, err
}
return statementFromPb(s), nil
}
|
go
|
func SqlFromPb(pb []byte) (SqlStatement, error) {
s := &SqlStatementPb{}
if err := proto.Unmarshal(pb, s); err != nil {
return nil, err
}
return statementFromPb(s), nil
}
|
[
"func",
"SqlFromPb",
"(",
"pb",
"[",
"]",
"byte",
")",
"(",
"SqlStatement",
",",
"error",
")",
"{",
"s",
":=",
"&",
"SqlStatementPb",
"{",
"}",
"\n",
"if",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"pb",
",",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"statementFromPb",
"(",
"s",
")",
",",
"nil",
"\n",
"}"
] |
// SqlFromPb Create a sql statement from pb
|
[
"SqlFromPb",
"Create",
"a",
"sql",
"statement",
"from",
"pb"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/sql.go#L1985-L1991
|
20,602
|
araddon/qlbridge
|
rel/sql.go
|
EqualWith
|
func EqualWith(l, r u.JsonHelper) bool {
if len(l) != len(r) {
return false
}
if len(l) == 0 && len(r) == 0 {
return true
}
for k, lv := range l {
rv, ok := r[k]
if !ok {
return false
}
switch lvt := lv.(type) {
case int, int64, int32, string, bool, float64:
if lv != rv {
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) {
return false
}
default:
u.Warnf("unhandled type comparison: %T", lv)
}
}
return true
}
|
go
|
func EqualWith(l, r u.JsonHelper) bool {
if len(l) != len(r) {
return false
}
if len(l) == 0 && len(r) == 0 {
return true
}
for k, lv := range l {
rv, ok := r[k]
if !ok {
return false
}
switch lvt := lv.(type) {
case int, int64, int32, string, bool, float64:
if lv != rv {
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) {
return false
}
default:
u.Warnf("unhandled type comparison: %T", lv)
}
}
return true
}
|
[
"func",
"EqualWith",
"(",
"l",
",",
"r",
"u",
".",
"JsonHelper",
")",
"bool",
"{",
"if",
"len",
"(",
"l",
")",
"!=",
"len",
"(",
"r",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"len",
"(",
"l",
")",
"==",
"0",
"&&",
"len",
"(",
"r",
")",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"for",
"k",
",",
"lv",
":=",
"range",
"l",
"{",
"rv",
",",
"ok",
":=",
"r",
"[",
"k",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"switch",
"lvt",
":=",
"lv",
".",
"(",
"type",
")",
"{",
"case",
"int",
",",
"int64",
",",
"int32",
",",
"string",
",",
"bool",
",",
"float64",
":",
"if",
"lv",
"!=",
"rv",
"{",
"return",
"false",
"\n",
"}",
"\n",
"case",
"u",
".",
"JsonHelper",
":",
"rh",
",",
"isHelper",
":=",
"rv",
".",
"(",
"u",
".",
"JsonHelper",
")",
"\n",
"if",
"!",
"isHelper",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"EqualWith",
"(",
"lvt",
",",
"rh",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"case",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"rh",
",",
"isHelper",
":=",
"rv",
".",
"(",
"u",
".",
"JsonHelper",
")",
"\n",
"if",
"!",
"isHelper",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"EqualWith",
"(",
"u",
".",
"JsonHelper",
"(",
"lvt",
")",
",",
"rh",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"default",
":",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"lv",
")",
"\n",
"}",
"\n\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// EqualWith compare two with helpers for equality.
|
[
"EqualWith",
"compare",
"two",
"with",
"helpers",
"for",
"equality",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/sql.go#L2035-L2074
|
20,603
|
araddon/qlbridge
|
exec/executor.go
|
NewExecutor
|
func NewExecutor(ctx *plan.Context, planner plan.Planner) *JobExecutor {
e := &JobExecutor{}
e.Executor = e
e.Planner = planner
e.Ctx = ctx
return e
}
|
go
|
func NewExecutor(ctx *plan.Context, planner plan.Planner) *JobExecutor {
e := &JobExecutor{}
e.Executor = e
e.Planner = planner
e.Ctx = ctx
return e
}
|
[
"func",
"NewExecutor",
"(",
"ctx",
"*",
"plan",
".",
"Context",
",",
"planner",
"plan",
".",
"Planner",
")",
"*",
"JobExecutor",
"{",
"e",
":=",
"&",
"JobExecutor",
"{",
"}",
"\n",
"e",
".",
"Executor",
"=",
"e",
"\n",
"e",
".",
"Planner",
"=",
"planner",
"\n",
"e",
".",
"Ctx",
"=",
"ctx",
"\n",
"return",
"e",
"\n",
"}"
] |
// NewExecutor creates a new Job Executor.
|
[
"NewExecutor",
"creates",
"a",
"new",
"Job",
"Executor",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L36-L42
|
20,604
|
araddon/qlbridge
|
exec/executor.go
|
WalkPlan
|
func (m *JobExecutor) WalkPlan(p plan.Task) (Task, error) {
switch p := p.(type) {
case *plan.PreparedStatement:
return m.Executor.WalkPreparedStatement(p)
case *plan.Select:
if p.Ctx != nil && p.IsSchemaQuery() {
if p.Ctx.Schema != nil && p.Ctx.Schema.InfoSchema != nil {
p.Ctx.Schema = p.Ctx.Schema.InfoSchema
}
p.Stmt.SetSystemQry()
}
return m.Executor.WalkSelect(p)
case *plan.Upsert:
return m.Executor.WalkUpsert(p)
case *plan.Insert:
return m.Executor.WalkInsert(p)
case *plan.Update:
return m.Executor.WalkUpdate(p)
case *plan.Delete:
return m.Executor.WalkDelete(p)
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))
}
|
go
|
func (m *JobExecutor) WalkPlan(p plan.Task) (Task, error) {
switch p := p.(type) {
case *plan.PreparedStatement:
return m.Executor.WalkPreparedStatement(p)
case *plan.Select:
if p.Ctx != nil && p.IsSchemaQuery() {
if p.Ctx.Schema != nil && p.Ctx.Schema.InfoSchema != nil {
p.Ctx.Schema = p.Ctx.Schema.InfoSchema
}
p.Stmt.SetSystemQry()
}
return m.Executor.WalkSelect(p)
case *plan.Upsert:
return m.Executor.WalkUpsert(p)
case *plan.Insert:
return m.Executor.WalkInsert(p)
case *plan.Update:
return m.Executor.WalkUpdate(p)
case *plan.Delete:
return m.Executor.WalkDelete(p)
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))
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"WalkPlan",
"(",
"p",
"plan",
".",
"Task",
")",
"(",
"Task",
",",
"error",
")",
"{",
"switch",
"p",
":=",
"p",
".",
"(",
"type",
")",
"{",
"case",
"*",
"plan",
".",
"PreparedStatement",
":",
"return",
"m",
".",
"Executor",
".",
"WalkPreparedStatement",
"(",
"p",
")",
"\n",
"case",
"*",
"plan",
".",
"Select",
":",
"if",
"p",
".",
"Ctx",
"!=",
"nil",
"&&",
"p",
".",
"IsSchemaQuery",
"(",
")",
"{",
"if",
"p",
".",
"Ctx",
".",
"Schema",
"!=",
"nil",
"&&",
"p",
".",
"Ctx",
".",
"Schema",
".",
"InfoSchema",
"!=",
"nil",
"{",
"p",
".",
"Ctx",
".",
"Schema",
"=",
"p",
".",
"Ctx",
".",
"Schema",
".",
"InfoSchema",
"\n",
"}",
"\n",
"p",
".",
"Stmt",
".",
"SetSystemQry",
"(",
")",
"\n",
"}",
"\n",
"return",
"m",
".",
"Executor",
".",
"WalkSelect",
"(",
"p",
")",
"\n",
"case",
"*",
"plan",
".",
"Upsert",
":",
"return",
"m",
".",
"Executor",
".",
"WalkUpsert",
"(",
"p",
")",
"\n",
"case",
"*",
"plan",
".",
"Insert",
":",
"return",
"m",
".",
"Executor",
".",
"WalkInsert",
"(",
"p",
")",
"\n",
"case",
"*",
"plan",
".",
"Update",
":",
"return",
"m",
".",
"Executor",
".",
"WalkUpdate",
"(",
"p",
")",
"\n",
"case",
"*",
"plan",
".",
"Delete",
":",
"return",
"m",
".",
"Executor",
".",
"WalkDelete",
"(",
"p",
")",
"\n",
"case",
"*",
"plan",
".",
"Command",
":",
"return",
"m",
".",
"Executor",
".",
"WalkCommand",
"(",
"p",
")",
"\n\n",
"// DDL",
"case",
"*",
"plan",
".",
"Create",
":",
"return",
"m",
".",
"Executor",
".",
"WalkCreate",
"(",
"p",
")",
"\n",
"case",
"*",
"plan",
".",
"Drop",
":",
"return",
"m",
".",
"Executor",
".",
"WalkDrop",
"(",
"p",
")",
"\n",
"case",
"*",
"plan",
".",
"Alter",
":",
"return",
"m",
".",
"Executor",
".",
"WalkAlter",
"(",
"p",
")",
"\n",
"}",
"\n",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
")",
")",
"\n",
"}"
] |
// WalkPlan Main Entry point to take a Plan, and convert into Execution DAG
|
[
"WalkPlan",
"Main",
"Entry",
"point",
"to",
"take",
"a",
"Plan",
"and",
"convert",
"into",
"Execution",
"DAG"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L109-L141
|
20,605
|
araddon/qlbridge
|
exec/executor.go
|
WalkSelect
|
func (m *JobExecutor) WalkSelect(p *plan.Select) (Task, error) {
root := m.NewTask(p)
return root, m.WalkChildren(p, root)
}
|
go
|
func (m *JobExecutor) WalkSelect(p *plan.Select) (Task, error) {
root := m.NewTask(p)
return root, m.WalkChildren(p, root)
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"WalkSelect",
"(",
"p",
"*",
"plan",
".",
"Select",
")",
"(",
"Task",
",",
"error",
")",
"{",
"root",
":=",
"m",
".",
"NewTask",
"(",
"p",
")",
"\n",
"return",
"root",
",",
"m",
".",
"WalkChildren",
"(",
"p",
",",
"root",
")",
"\n",
"}"
] |
// DML
// WalkSelect create dag of plan Select.
|
[
"DML",
"WalkSelect",
"create",
"dag",
"of",
"plan",
"Select",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L151-L154
|
20,606
|
araddon/qlbridge
|
exec/executor.go
|
WalkCommand
|
func (m *JobExecutor) WalkCommand(p *plan.Command) (Task, error) {
root := m.NewTask(p)
return root, root.Add(NewCommand(m.Ctx, p))
}
|
go
|
func (m *JobExecutor) WalkCommand(p *plan.Command) (Task, error) {
root := m.NewTask(p)
return root, root.Add(NewCommand(m.Ctx, p))
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"WalkCommand",
"(",
"p",
"*",
"plan",
".",
"Command",
")",
"(",
"Task",
",",
"error",
")",
"{",
"root",
":=",
"m",
".",
"NewTask",
"(",
"p",
")",
"\n",
"return",
"root",
",",
"root",
".",
"Add",
"(",
"NewCommand",
"(",
"m",
".",
"Ctx",
",",
"p",
")",
")",
"\n",
"}"
] |
// Other Statements
// WalkCommand walk Commands such as SET.
|
[
"Other",
"Statements",
"WalkCommand",
"walk",
"Commands",
"such",
"as",
"SET",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L312-L315
|
20,607
|
araddon/qlbridge
|
exec/executor.go
|
WalkCreate
|
func (m *JobExecutor) WalkCreate(p *plan.Create) (Task, error) {
root := m.NewTask(p)
return root, root.Add(NewCreate(m.Ctx, p))
}
|
go
|
func (m *JobExecutor) WalkCreate(p *plan.Create) (Task, error) {
root := m.NewTask(p)
return root, root.Add(NewCreate(m.Ctx, p))
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"WalkCreate",
"(",
"p",
"*",
"plan",
".",
"Create",
")",
"(",
"Task",
",",
"error",
")",
"{",
"root",
":=",
"m",
".",
"NewTask",
"(",
"p",
")",
"\n",
"return",
"root",
",",
"root",
".",
"Add",
"(",
"NewCreate",
"(",
"m",
".",
"Ctx",
",",
"p",
")",
")",
"\n",
"}"
] |
// DDL Operations
// WalkCreate walks the Create plan.
|
[
"DDL",
"Operations",
"WalkCreate",
"walks",
"the",
"Create",
"plan",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L320-L323
|
20,608
|
araddon/qlbridge
|
exec/executor.go
|
WalkDrop
|
func (m *JobExecutor) WalkDrop(p *plan.Drop) (Task, error) {
root := m.NewTask(p)
return root, root.Add(NewDrop(m.Ctx, p))
}
|
go
|
func (m *JobExecutor) WalkDrop(p *plan.Drop) (Task, error) {
root := m.NewTask(p)
return root, root.Add(NewDrop(m.Ctx, p))
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"WalkDrop",
"(",
"p",
"*",
"plan",
".",
"Drop",
")",
"(",
"Task",
",",
"error",
")",
"{",
"root",
":=",
"m",
".",
"NewTask",
"(",
"p",
")",
"\n",
"return",
"root",
",",
"root",
".",
"Add",
"(",
"NewDrop",
"(",
"m",
".",
"Ctx",
",",
"p",
")",
")",
"\n",
"}"
] |
// WalkDrop walks the Drop plan.
|
[
"WalkDrop",
"walks",
"the",
"Drop",
"plan",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L326-L329
|
20,609
|
araddon/qlbridge
|
exec/executor.go
|
WalkAlter
|
func (m *JobExecutor) WalkAlter(p *plan.Alter) (Task, error) {
root := m.NewTask(p)
return root, root.Add(NewAlter(m.Ctx, p))
}
|
go
|
func (m *JobExecutor) WalkAlter(p *plan.Alter) (Task, error) {
root := m.NewTask(p)
return root, root.Add(NewAlter(m.Ctx, p))
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"WalkAlter",
"(",
"p",
"*",
"plan",
".",
"Alter",
")",
"(",
"Task",
",",
"error",
")",
"{",
"root",
":=",
"m",
".",
"NewTask",
"(",
"p",
")",
"\n",
"return",
"root",
",",
"root",
".",
"Add",
"(",
"NewAlter",
"(",
"m",
".",
"Ctx",
",",
"p",
")",
")",
"\n",
"}"
] |
// WalkAlter walks the Alter plan.
|
[
"WalkAlter",
"walks",
"the",
"Alter",
"plan",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L332-L335
|
20,610
|
araddon/qlbridge
|
exec/executor.go
|
WalkChildren
|
func (m *JobExecutor) WalkChildren(p plan.Task, root Task) error {
for _, t := range p.Children() {
//u.Debugf("parent: %T walk child %p %T %#v", p, t, t, p.Children())
et, err := m.WalkPlanTask(t)
if err != nil {
u.Errorf("could not create task %#v err=%v", t, err)
}
if len(t.Children()) == 0 {
err = root.Add(et)
if err != nil {
return err
}
} else {
childRoot := m.Executor.NewTask(t)
err = root.Add(childRoot)
if err != nil {
return err
}
err = childRoot.Add(et)
if err != nil {
return err
}
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
}
|
go
|
func (m *JobExecutor) WalkChildren(p plan.Task, root Task) error {
for _, t := range p.Children() {
//u.Debugf("parent: %T walk child %p %T %#v", p, t, t, p.Children())
et, err := m.WalkPlanTask(t)
if err != nil {
u.Errorf("could not create task %#v err=%v", t, err)
}
if len(t.Children()) == 0 {
err = root.Add(et)
if err != nil {
return err
}
} else {
childRoot := m.Executor.NewTask(t)
err = root.Add(childRoot)
if err != nil {
return err
}
err = childRoot.Add(et)
if err != nil {
return err
}
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
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"WalkChildren",
"(",
"p",
"plan",
".",
"Task",
",",
"root",
"Task",
")",
"error",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"p",
".",
"Children",
"(",
")",
"{",
"//u.Debugf(\"parent: %T walk child %p %T %#v\", p, t, t, p.Children())",
"et",
",",
"err",
":=",
"m",
".",
"WalkPlanTask",
"(",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"t",
".",
"Children",
"(",
")",
")",
"==",
"0",
"{",
"err",
"=",
"root",
".",
"Add",
"(",
"et",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"childRoot",
":=",
"m",
".",
"Executor",
".",
"NewTask",
"(",
"t",
")",
"\n",
"err",
"=",
"root",
".",
"Add",
"(",
"childRoot",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"childRoot",
".",
"Add",
"(",
"et",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"t",
".",
"Children",
"(",
")",
"{",
"ct",
",",
"err",
":=",
"m",
".",
"WalkPlanTask",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"childRoot",
".",
"Add",
"(",
"ct",
")",
";",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// WalkChildren walk dag of plan tasks creating execution tasks
|
[
"WalkChildren",
"walk",
"dag",
"of",
"plan",
"tasks",
"creating",
"execution",
"tasks"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L338-L374
|
20,611
|
araddon/qlbridge
|
exec/executor.go
|
Setup
|
func (m *JobExecutor) Setup() error {
if m == nil {
return fmt.Errorf("JobExecutor is nil?")
}
if m.RootTask == nil {
return fmt.Errorf("No task exists for this job")
}
return m.RootTask.Setup(0)
}
|
go
|
func (m *JobExecutor) Setup() error {
if m == nil {
return fmt.Errorf("JobExecutor is nil?")
}
if m.RootTask == nil {
return fmt.Errorf("No task exists for this job")
}
return m.RootTask.Setup(0)
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"Setup",
"(",
")",
"error",
"{",
"if",
"m",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"RootTask",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"m",
".",
"RootTask",
".",
"Setup",
"(",
"0",
")",
"\n",
"}"
] |
// Setup this dag of tasks
|
[
"Setup",
"this",
"dag",
"of",
"tasks"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L377-L385
|
20,612
|
araddon/qlbridge
|
exec/executor.go
|
DrainChan
|
func (m *JobExecutor) DrainChan() MessageChan {
tasks := m.RootTask.Children()
return tasks[len(tasks)-1].(TaskRunner).MessageOut()
}
|
go
|
func (m *JobExecutor) DrainChan() MessageChan {
tasks := m.RootTask.Children()
return tasks[len(tasks)-1].(TaskRunner).MessageOut()
}
|
[
"func",
"(",
"m",
"*",
"JobExecutor",
")",
"DrainChan",
"(",
")",
"MessageChan",
"{",
"tasks",
":=",
"m",
".",
"RootTask",
".",
"Children",
"(",
")",
"\n",
"return",
"tasks",
"[",
"len",
"(",
"tasks",
")",
"-",
"1",
"]",
".",
"(",
"TaskRunner",
")",
".",
"MessageOut",
"(",
")",
"\n",
"}"
] |
// The drain is the last out channel, on last task
|
[
"The",
"drain",
"is",
"the",
"last",
"out",
"channel",
"on",
"last",
"task"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/executor.go#L398-L401
|
20,613
|
araddon/qlbridge
|
expr/builtins/url_email.go
|
UrlWithQueryEval
|
func UrlWithQueryEval(include []*regexp.Regexp) expr.EvaluatorFunc {
return func(ctx expr.EvalContext, args []value.Value) (value.Value, bool) {
val := ""
switch itemT := args[0].(type) {
case value.StringValue:
val = itemT.Val()
case value.Slice:
if itemT.Len() == 0 {
return value.EmptyStringValue, false
}
val = itemT.SliceValue()[0].ToString()
}
if val == "" {
return value.EmptyStringValue, false
}
up, err := url.Parse(val)
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 include {
if pattern.MatchString(k) {
newvals[k] = v
break
}
}
}
up.RawQuery = newvals.Encode()
if up.RawQuery == "" {
return value.NewStringValue(fmt.Sprintf("%s%s", up.Host, up.Path)), true
}
return value.NewStringValue(fmt.Sprintf("%s%s?%s", up.Host, up.Path, up.RawQuery)), true
}
}
|
go
|
func UrlWithQueryEval(include []*regexp.Regexp) expr.EvaluatorFunc {
return func(ctx expr.EvalContext, args []value.Value) (value.Value, bool) {
val := ""
switch itemT := args[0].(type) {
case value.StringValue:
val = itemT.Val()
case value.Slice:
if itemT.Len() == 0 {
return value.EmptyStringValue, false
}
val = itemT.SliceValue()[0].ToString()
}
if val == "" {
return value.EmptyStringValue, false
}
up, err := url.Parse(val)
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 include {
if pattern.MatchString(k) {
newvals[k] = v
break
}
}
}
up.RawQuery = newvals.Encode()
if up.RawQuery == "" {
return value.NewStringValue(fmt.Sprintf("%s%s", up.Host, up.Path)), true
}
return value.NewStringValue(fmt.Sprintf("%s%s?%s", up.Host, up.Path, up.RawQuery)), true
}
}
|
[
"func",
"UrlWithQueryEval",
"(",
"include",
"[",
"]",
"*",
"regexp",
".",
"Regexp",
")",
"expr",
".",
"EvaluatorFunc",
"{",
"return",
"func",
"(",
"ctx",
"expr",
".",
"EvalContext",
",",
"args",
"[",
"]",
"value",
".",
"Value",
")",
"(",
"value",
".",
"Value",
",",
"bool",
")",
"{",
"val",
":=",
"\"",
"\"",
"\n",
"switch",
"itemT",
":=",
"args",
"[",
"0",
"]",
".",
"(",
"type",
")",
"{",
"case",
"value",
".",
"StringValue",
":",
"val",
"=",
"itemT",
".",
"Val",
"(",
")",
"\n",
"case",
"value",
".",
"Slice",
":",
"if",
"itemT",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"value",
".",
"EmptyStringValue",
",",
"false",
"\n",
"}",
"\n",
"val",
"=",
"itemT",
".",
"SliceValue",
"(",
")",
"[",
"0",
"]",
".",
"ToString",
"(",
")",
"\n",
"}",
"\n",
"if",
"val",
"==",
"\"",
"\"",
"{",
"return",
"value",
".",
"EmptyStringValue",
",",
"false",
"\n",
"}",
"\n\n",
"up",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"val",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"value",
".",
"EmptyStringValue",
",",
"false",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"args",
")",
"==",
"1",
"{",
"return",
"value",
".",
"NewStringValue",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"up",
".",
"Host",
",",
"up",
".",
"Path",
")",
")",
",",
"true",
"\n",
"}",
"\n\n",
"oldvals",
":=",
"up",
".",
"Query",
"(",
")",
"\n",
"newvals",
":=",
"make",
"(",
"url",
".",
"Values",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"oldvals",
"{",
"// include fields specified as arguments",
"for",
"_",
",",
"pattern",
":=",
"range",
"include",
"{",
"if",
"pattern",
".",
"MatchString",
"(",
"k",
")",
"{",
"newvals",
"[",
"k",
"]",
"=",
"v",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"up",
".",
"RawQuery",
"=",
"newvals",
".",
"Encode",
"(",
")",
"\n",
"if",
"up",
".",
"RawQuery",
"==",
"\"",
"\"",
"{",
"return",
"value",
".",
"NewStringValue",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"up",
".",
"Host",
",",
"up",
".",
"Path",
")",
")",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"value",
".",
"NewStringValue",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"up",
".",
"Host",
",",
"up",
".",
"Path",
",",
"up",
".",
"RawQuery",
")",
")",
",",
"true",
"\n",
"}",
"\n",
"}"
] |
// UrlWithQueryEval pass reg-expressions to match qs args.
// Must match one regexp or else the qs param is dropped.
|
[
"UrlWithQueryEval",
"pass",
"reg",
"-",
"expressions",
"to",
"match",
"qs",
"args",
".",
"Must",
"match",
"one",
"regexp",
"or",
"else",
"the",
"qs",
"param",
"is",
"dropped",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/expr/builtins/url_email.go#L645-L690
|
20,614
|
araddon/qlbridge
|
datasource/schemadb.go
|
SchemaDBStoreProvider
|
func SchemaDBStoreProvider(s *schema.Schema) schema.Source {
schemaDb := NewSchemaDb(s)
s.InfoSchema.DS = schemaDb
return schemaDb
}
|
go
|
func SchemaDBStoreProvider(s *schema.Schema) schema.Source {
schemaDb := NewSchemaDb(s)
s.InfoSchema.DS = schemaDb
return schemaDb
}
|
[
"func",
"SchemaDBStoreProvider",
"(",
"s",
"*",
"schema",
".",
"Schema",
")",
"schema",
".",
"Source",
"{",
"schemaDb",
":=",
"NewSchemaDb",
"(",
"s",
")",
"\n",
"s",
".",
"InfoSchema",
".",
"DS",
"=",
"schemaDb",
"\n",
"return",
"schemaDb",
"\n",
"}"
] |
// SchemaDBStoreProvider create source for schemadb
|
[
"SchemaDBStoreProvider",
"create",
"source",
"for",
"schemadb"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/schemadb.go#L68-L72
|
20,615
|
araddon/qlbridge
|
datasource/schemadb.go
|
NewSchemaDb
|
func NewSchemaDb(s *schema.Schema) *SchemaDb {
m := SchemaDb{
s: s,
tbls: defaultSchemaTables,
tableMap: make(map[string]*schema.Table),
}
return &m
}
|
go
|
func NewSchemaDb(s *schema.Schema) *SchemaDb {
m := SchemaDb{
s: s,
tbls: defaultSchemaTables,
tableMap: make(map[string]*schema.Table),
}
return &m
}
|
[
"func",
"NewSchemaDb",
"(",
"s",
"*",
"schema",
".",
"Schema",
")",
"*",
"SchemaDb",
"{",
"m",
":=",
"SchemaDb",
"{",
"s",
":",
"s",
",",
"tbls",
":",
"defaultSchemaTables",
",",
"tableMap",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"schema",
".",
"Table",
")",
",",
"}",
"\n",
"return",
"&",
"m",
"\n",
"}"
] |
// NewSchemaDb create new db for storing schema.
|
[
"NewSchemaDb",
"create",
"new",
"db",
"for",
"storing",
"schema",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/schemadb.go#L75-L82
|
20,616
|
araddon/qlbridge
|
datasource/schemadb.go
|
Table
|
func (m *SchemaDb) Table(table string) (*schema.Table, error) {
switch table {
case "tables":
return m.tableForTables()
case "databases":
return m.tableForDatabases()
case "session_variables", "global_variables":
return m.tableForVariables(table)
case "procedures", "functions":
return m.tableForProcedures(table)
case "engines":
return m.tableForEngines()
case "indexes", "keys":
return m.tableForIndexes()
case "status":
return m.tableForVariables(table)
case "columns":
return m.tableForTable(table)
default:
return m.tableForTable(table)
}
}
|
go
|
func (m *SchemaDb) Table(table string) (*schema.Table, error) {
switch table {
case "tables":
return m.tableForTables()
case "databases":
return m.tableForDatabases()
case "session_variables", "global_variables":
return m.tableForVariables(table)
case "procedures", "functions":
return m.tableForProcedures(table)
case "engines":
return m.tableForEngines()
case "indexes", "keys":
return m.tableForIndexes()
case "status":
return m.tableForVariables(table)
case "columns":
return m.tableForTable(table)
default:
return m.tableForTable(table)
}
}
|
[
"func",
"(",
"m",
"*",
"SchemaDb",
")",
"Table",
"(",
"table",
"string",
")",
"(",
"*",
"schema",
".",
"Table",
",",
"error",
")",
"{",
"switch",
"table",
"{",
"case",
"\"",
"\"",
":",
"return",
"m",
".",
"tableForTables",
"(",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"m",
".",
"tableForDatabases",
"(",
")",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"m",
".",
"tableForVariables",
"(",
"table",
")",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"m",
".",
"tableForProcedures",
"(",
"table",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"m",
".",
"tableForEngines",
"(",
")",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"m",
".",
"tableForIndexes",
"(",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"m",
".",
"tableForVariables",
"(",
"table",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"m",
".",
"tableForTable",
"(",
"table",
")",
"\n",
"default",
":",
"return",
"m",
".",
"tableForTable",
"(",
"table",
")",
"\n",
"}",
"\n",
"}"
] |
// Table get schema Table
|
[
"Table",
"get",
"schema",
"Table"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/schemadb.go#L99-L121
|
20,617
|
araddon/qlbridge
|
datasource/schemadb.go
|
SetContext
|
func (m *SchemaSource) SetContext(ctx *plan.Context) {
m.ctx = ctx
if m.session {
m.rows = RowsForSession(ctx)
}
}
|
go
|
func (m *SchemaSource) SetContext(ctx *plan.Context) {
m.ctx = ctx
if m.session {
m.rows = RowsForSession(ctx)
}
}
|
[
"func",
"(",
"m",
"*",
"SchemaSource",
")",
"SetContext",
"(",
"ctx",
"*",
"plan",
".",
"Context",
")",
"{",
"m",
".",
"ctx",
"=",
"ctx",
"\n",
"if",
"m",
".",
"session",
"{",
"m",
".",
"rows",
"=",
"RowsForSession",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"}"
] |
// SetContext set the plan context
|
[
"SetContext",
"set",
"the",
"plan",
"context"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/schemadb.go#L143-L148
|
20,618
|
araddon/qlbridge
|
datasource/schemadb.go
|
Table
|
func (m *mysqlWriter) Table(tbl *schema.Table) string {
w := &bytes.Buffer{}
//u.Infof("%s tbl=%p fields? %#v fields?%v", tbl.Name, tbl, tbl.FieldMap, len(tbl.Fields))
fmt.Fprintf(w, "CREATE TABLE `%s` (", tbl.Name)
for i, fld := range tbl.Fields {
if i != 0 {
w.WriteByte(',')
}
fmt.Fprint(w, "\n ")
mysqlWriteField(w, fld)
}
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()
}
|
go
|
func (m *mysqlWriter) Table(tbl *schema.Table) string {
w := &bytes.Buffer{}
//u.Infof("%s tbl=%p fields? %#v fields?%v", tbl.Name, tbl, tbl.FieldMap, len(tbl.Fields))
fmt.Fprintf(w, "CREATE TABLE `%s` (", tbl.Name)
for i, fld := range tbl.Fields {
if i != 0 {
w.WriteByte(',')
}
fmt.Fprint(w, "\n ")
mysqlWriteField(w, fld)
}
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()
}
|
[
"func",
"(",
"m",
"*",
"mysqlWriter",
")",
"Table",
"(",
"tbl",
"*",
"schema",
".",
"Table",
")",
"string",
"{",
"w",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"//u.Infof(\"%s tbl=%p fields? %#v fields?%v\", tbl.Name, tbl, tbl.FieldMap, len(tbl.Fields))",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\"",
",",
"tbl",
".",
"Name",
")",
"\n",
"for",
"i",
",",
"fld",
":=",
"range",
"tbl",
".",
"Fields",
"{",
"if",
"i",
"!=",
"0",
"{",
"w",
".",
"WriteByte",
"(",
"','",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprint",
"(",
"w",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"mysqlWriteField",
"(",
"w",
",",
"fld",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprint",
"(",
"w",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"//tblStr := fmt.Sprintf(\"CREATE TABLE `%s` (\\n\\n);\", tbl.Name, strings.Join(cols, \",\"))",
"//return tblStr, nil",
"return",
"w",
".",
"String",
"(",
")",
"\n",
"}"
] |
// Table Implement Dialect Specific Writers
// ie, mysql, postgres, cassandra all have different dialects
// so the Create statements are quite different
// Table output a CREATE TABLE statement using mysql dialect.
|
[
"Table",
"Implement",
"Dialect",
"Specific",
"Writers",
"ie",
"mysql",
"postgres",
"cassandra",
"all",
"have",
"different",
"dialects",
"so",
"the",
"Create",
"statements",
"are",
"quite",
"different",
"Table",
"output",
"a",
"CREATE",
"TABLE",
"statement",
"using",
"mysql",
"dialect",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/schemadb.go#L406-L422
|
20,619
|
araddon/qlbridge
|
plan/planner.go
|
NewPlanner
|
func NewPlanner(ctx *Context) *PlannerDefault {
p := &PlannerDefault{
Ctx: ctx,
children: make([]Task, 0),
}
p.Planner = p
return p
}
|
go
|
func NewPlanner(ctx *Context) *PlannerDefault {
p := &PlannerDefault{
Ctx: ctx,
children: make([]Task, 0),
}
p.Planner = p
return p
}
|
[
"func",
"NewPlanner",
"(",
"ctx",
"*",
"Context",
")",
"*",
"PlannerDefault",
"{",
"p",
":=",
"&",
"PlannerDefault",
"{",
"Ctx",
":",
"ctx",
",",
"children",
":",
"make",
"(",
"[",
"]",
"Task",
",",
"0",
")",
",",
"}",
"\n",
"p",
".",
"Planner",
"=",
"p",
"\n",
"return",
"p",
"\n",
"}"
] |
// NewPlanner creates a new default planner with context.
|
[
"NewPlanner",
"creates",
"a",
"new",
"default",
"planner",
"with",
"context",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/plan/planner.go#L27-L34
|
20,620
|
araddon/qlbridge
|
plan/planner.go
|
WalkCommand
|
func (m *PlannerDefault) WalkCommand(p *Command) error {
u.Debugf("WalkCommand %+v", p.Stmt)
return nil
}
|
go
|
func (m *PlannerDefault) WalkCommand(p *Command) error {
u.Debugf("WalkCommand %+v", p.Stmt)
return nil
}
|
[
"func",
"(",
"m",
"*",
"PlannerDefault",
")",
"WalkCommand",
"(",
"p",
"*",
"Command",
")",
"error",
"{",
"u",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"p",
".",
"Stmt",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// WalkCommand walks the command statement
|
[
"WalkCommand",
"walks",
"the",
"command",
"statement"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/plan/planner.go#L43-L46
|
20,621
|
araddon/qlbridge
|
plan/planner.go
|
WalkDrop
|
func (m *PlannerDefault) WalkDrop(p *Drop) error {
u.Debugf("WalkDrop %+v", p.Stmt)
return nil
}
|
go
|
func (m *PlannerDefault) WalkDrop(p *Drop) error {
u.Debugf("WalkDrop %+v", p.Stmt)
return nil
}
|
[
"func",
"(",
"m",
"*",
"PlannerDefault",
")",
"WalkDrop",
"(",
"p",
"*",
"Drop",
")",
"error",
"{",
"u",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"p",
".",
"Stmt",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// WalkDrop walks the draop statement
|
[
"WalkDrop",
"walks",
"the",
"draop",
"statement"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/plan/planner.go#L49-L52
|
20,622
|
araddon/qlbridge
|
plan/planner.go
|
WalkCreate
|
func (m *PlannerDefault) WalkCreate(p *Create) error {
u.Debugf("WalkCreate %#v", p)
if len(p.Stmt.With) == 0 {
return fmt.Errorf("CREATE {SCHEMA|SOURCE|DATABASE}")
}
return nil
}
|
go
|
func (m *PlannerDefault) WalkCreate(p *Create) error {
u.Debugf("WalkCreate %#v", p)
if len(p.Stmt.With) == 0 {
return fmt.Errorf("CREATE {SCHEMA|SOURCE|DATABASE}")
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"PlannerDefault",
")",
"WalkCreate",
"(",
"p",
"*",
"Create",
")",
"error",
"{",
"u",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"p",
")",
"\n",
"if",
"len",
"(",
"p",
".",
"Stmt",
".",
"With",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// WalkCreate walk a Create Plan to create the dag of tasks for Create.
|
[
"WalkCreate",
"walk",
"a",
"Create",
"Plan",
"to",
"create",
"the",
"dag",
"of",
"tasks",
"for",
"Create",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/plan/planner.go#L55-L61
|
20,623
|
araddon/qlbridge
|
plan/planner.go
|
WalkAlter
|
func (m *PlannerDefault) WalkAlter(p *Alter) error {
u.Debugf("WalkAlter %#v", p)
return nil
}
|
go
|
func (m *PlannerDefault) WalkAlter(p *Alter) error {
u.Debugf("WalkAlter %#v", p)
return nil
}
|
[
"func",
"(",
"m",
"*",
"PlannerDefault",
")",
"WalkAlter",
"(",
"p",
"*",
"Alter",
")",
"error",
"{",
"u",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"p",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// WalkAlter walk a ALTER Plan to create the dag of tasks forAlter.
|
[
"WalkAlter",
"walk",
"a",
"ALTER",
"Plan",
"to",
"create",
"the",
"dag",
"of",
"tasks",
"forAlter",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/plan/planner.go#L64-L67
|
20,624
|
araddon/qlbridge
|
lex/token.go
|
String
|
func (t Token) String() string {
return fmt.Sprintf(`Token{ %s Type:"%v" Line:%d Col:%d Q:%s Pos:%d}`,
t.V, t.T.String(), t.Line, t.Column, string(t.Quote), t.Pos)
}
|
go
|
func (t Token) String() string {
return fmt.Sprintf(`Token{ %s Type:"%v" Line:%d Col:%d Q:%s Pos:%d}`,
t.V, t.T.String(), t.Line, t.Column, string(t.Quote), t.Pos)
}
|
[
"func",
"(",
"t",
"Token",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"`Token{ %s Type:\"%v\" Line:%d Col:%d Q:%s Pos:%d}`",
",",
"t",
".",
"V",
",",
"t",
".",
"T",
".",
"String",
"(",
")",
",",
"t",
".",
"Line",
",",
"t",
".",
"Column",
",",
"string",
"(",
"t",
".",
"Quote",
")",
",",
"t",
".",
"Pos",
")",
"\n",
"}"
] |
// convert to human readable string
|
[
"convert",
"to",
"human",
"readable",
"string"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/lex/token.go#L31-L34
|
20,625
|
araddon/qlbridge
|
lex/token.go
|
LoadTokenInfo
|
func LoadTokenInfo() {
for tok, ti := range TokenNameMap {
ti.T = tok
if ti.Kw == "" {
ti.Kw = ti.Description
}
TokenToOp[ti.Kw] = tok
if strings.Contains(ti.Kw, " ") {
parts := strings.Split(ti.Kw, " ")
ti.firstWord = parts[0]
ti.HasSpaces = true
}
}
}
|
go
|
func LoadTokenInfo() {
for tok, ti := range TokenNameMap {
ti.T = tok
if ti.Kw == "" {
ti.Kw = ti.Description
}
TokenToOp[ti.Kw] = tok
if strings.Contains(ti.Kw, " ") {
parts := strings.Split(ti.Kw, " ")
ti.firstWord = parts[0]
ti.HasSpaces = true
}
}
}
|
[
"func",
"LoadTokenInfo",
"(",
")",
"{",
"for",
"tok",
",",
"ti",
":=",
"range",
"TokenNameMap",
"{",
"ti",
".",
"T",
"=",
"tok",
"\n",
"if",
"ti",
".",
"Kw",
"==",
"\"",
"\"",
"{",
"ti",
".",
"Kw",
"=",
"ti",
".",
"Description",
"\n",
"}",
"\n",
"TokenToOp",
"[",
"ti",
".",
"Kw",
"]",
"=",
"tok",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"ti",
".",
"Kw",
",",
"\"",
"\"",
")",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"ti",
".",
"Kw",
",",
"\"",
"\"",
")",
"\n",
"ti",
".",
"firstWord",
"=",
"parts",
"[",
"0",
"]",
"\n",
"ti",
".",
"HasSpaces",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// LoadTokenInfo load the token info into global map
|
[
"LoadTokenInfo",
"load",
"the",
"token",
"info",
"into",
"global",
"map"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/lex/token.go#L443-L456
|
20,626
|
araddon/qlbridge
|
lex/token.go
|
TokenFromOp
|
func TokenFromOp(op string) Token {
tt, ok := TokenToOp[op]
if ok {
return Token{T: tt, V: op}
}
return Token{T: TokenNil}
}
|
go
|
func TokenFromOp(op string) Token {
tt, ok := TokenToOp[op]
if ok {
return Token{T: tt, V: op}
}
return Token{T: TokenNil}
}
|
[
"func",
"TokenFromOp",
"(",
"op",
"string",
")",
"Token",
"{",
"tt",
",",
"ok",
":=",
"TokenToOp",
"[",
"op",
"]",
"\n",
"if",
"ok",
"{",
"return",
"Token",
"{",
"T",
":",
"tt",
",",
"V",
":",
"op",
"}",
"\n",
"}",
"\n",
"return",
"Token",
"{",
"T",
":",
"TokenNil",
"}",
"\n",
"}"
] |
// TokenFromOp get token from operation string
|
[
"TokenFromOp",
"get",
"token",
"from",
"operation",
"string"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/lex/token.go#L459-L465
|
20,627
|
araddon/qlbridge
|
lex/token.go
|
String
|
func (typ TokenType) String() string {
s, ok := TokenNameMap[typ]
if ok {
return s.Kw
}
return "not implemented"
}
|
go
|
func (typ TokenType) String() string {
s, ok := TokenNameMap[typ]
if ok {
return s.Kw
}
return "not implemented"
}
|
[
"func",
"(",
"typ",
"TokenType",
")",
"String",
"(",
")",
"string",
"{",
"s",
",",
"ok",
":=",
"TokenNameMap",
"[",
"typ",
"]",
"\n",
"if",
"ok",
"{",
"return",
"s",
".",
"Kw",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] |
// String convert to human readable string
|
[
"String",
"convert",
"to",
"human",
"readable",
"string"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/lex/token.go#L468-L474
|
20,628
|
araddon/qlbridge
|
lex/token.go
|
MatchString
|
func (typ TokenType) MatchString() string {
tokInfo, ok := TokenNameMap[typ]
//u.Debugf("matchstring: '%v' '%v' '%v'", tokInfo.T, tokInfo.Kw, tokInfo.Description)
if ok {
if tokInfo.HasSpaces {
return tokInfo.firstWord
}
return tokInfo.Kw
}
return "not implemented"
}
|
go
|
func (typ TokenType) MatchString() string {
tokInfo, ok := TokenNameMap[typ]
//u.Debugf("matchstring: '%v' '%v' '%v'", tokInfo.T, tokInfo.Kw, tokInfo.Description)
if ok {
if tokInfo.HasSpaces {
return tokInfo.firstWord
}
return tokInfo.Kw
}
return "not implemented"
}
|
[
"func",
"(",
"typ",
"TokenType",
")",
"MatchString",
"(",
")",
"string",
"{",
"tokInfo",
",",
"ok",
":=",
"TokenNameMap",
"[",
"typ",
"]",
"\n",
"//u.Debugf(\"matchstring: '%v' '%v' '%v'\", tokInfo.T, tokInfo.Kw, tokInfo.Description)",
"if",
"ok",
"{",
"if",
"tokInfo",
".",
"HasSpaces",
"{",
"return",
"tokInfo",
".",
"firstWord",
"\n",
"}",
"\n",
"return",
"tokInfo",
".",
"Kw",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] |
// MatchString which keyword should we look for, either full keyword
// OR in case of spaces such as "group by" look for group
|
[
"MatchString",
"which",
"keyword",
"should",
"we",
"look",
"for",
"either",
"full",
"keyword",
"OR",
"in",
"case",
"of",
"spaces",
"such",
"as",
"group",
"by",
"look",
"for",
"group"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/lex/token.go#L478-L488
|
20,629
|
araddon/qlbridge
|
lex/token.go
|
MultiWord
|
func (typ TokenType) MultiWord() bool {
tokInfo, ok := TokenNameMap[typ]
if ok {
return tokInfo.HasSpaces
}
return false
}
|
go
|
func (typ TokenType) MultiWord() bool {
tokInfo, ok := TokenNameMap[typ]
if ok {
return tokInfo.HasSpaces
}
return false
}
|
[
"func",
"(",
"typ",
"TokenType",
")",
"MultiWord",
"(",
")",
"bool",
"{",
"tokInfo",
",",
"ok",
":=",
"TokenNameMap",
"[",
"typ",
"]",
"\n",
"if",
"ok",
"{",
"return",
"tokInfo",
".",
"HasSpaces",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// MultiWord is this a word such as "Group by" with multiple words?
|
[
"MultiWord",
"is",
"this",
"a",
"word",
"such",
"as",
"Group",
"by",
"with",
"multiple",
"words?"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/lex/token.go#L491-L497
|
20,630
|
araddon/qlbridge
|
schema/registry.go
|
OpenConn
|
func OpenConn(schemaName, table string) (Conn, error) {
registry.mu.Lock()
defer registry.mu.Unlock()
schema, ok := registry.schemas[strings.ToLower(schemaName)]
if !ok {
return nil, fmt.Errorf("unknown schema %q", schemaName)
}
return schema.OpenConn(table)
}
|
go
|
func OpenConn(schemaName, table string) (Conn, error) {
registry.mu.Lock()
defer registry.mu.Unlock()
schema, ok := registry.schemas[strings.ToLower(schemaName)]
if !ok {
return nil, fmt.Errorf("unknown schema %q", schemaName)
}
return schema.OpenConn(table)
}
|
[
"func",
"OpenConn",
"(",
"schemaName",
",",
"table",
"string",
")",
"(",
"Conn",
",",
"error",
")",
"{",
"registry",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"registry",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"schema",
",",
"ok",
":=",
"registry",
".",
"schemas",
"[",
"strings",
".",
"ToLower",
"(",
"schemaName",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"schemaName",
")",
"\n",
"}",
"\n",
"return",
"schema",
".",
"OpenConn",
"(",
"table",
")",
"\n",
"}"
] |
// OpenConn a schema-source Connection, Global open connection function using
// default schema registry.
|
[
"OpenConn",
"a",
"schema",
"-",
"source",
"Connection",
"Global",
"open",
"connection",
"function",
"using",
"default",
"schema",
"registry",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L47-L55
|
20,631
|
araddon/qlbridge
|
schema/registry.go
|
RegisterSourceType
|
func RegisterSourceType(sourceType string, source Source) {
registryMu.Lock()
defer registryMu.Unlock()
registry.addSourceType(sourceType, source)
}
|
go
|
func RegisterSourceType(sourceType string, source Source) {
registryMu.Lock()
defer registryMu.Unlock()
registry.addSourceType(sourceType, source)
}
|
[
"func",
"RegisterSourceType",
"(",
"sourceType",
"string",
",",
"source",
"Source",
")",
"{",
"registryMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"registryMu",
".",
"Unlock",
"(",
")",
"\n",
"registry",
".",
"addSourceType",
"(",
"sourceType",
",",
"source",
")",
"\n",
"}"
] |
// RegisterSourceType makes a datasource type available by the provided @sourceType
// If Register is called twice with the same name or if source is nil, it panics.
//
// Sources are specific schemas of type csv, elasticsearch, etc containing
// multiple tables.
|
[
"RegisterSourceType",
"makes",
"a",
"datasource",
"type",
"available",
"by",
"the",
"provided"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L62-L66
|
20,632
|
araddon/qlbridge
|
schema/registry.go
|
RegisterSourceAsSchema
|
func RegisterSourceAsSchema(name string, source Source) error {
// Since registry is a global, lets first lock that.
registryMu.Lock()
defer registryMu.Unlock()
s := NewSchemaSource(name, source)
source.Init()
source.Setup(s)
if err := registry.SchemaAdd(s); err != nil {
return err
}
return discoverSchemaFromSource(s, registry.applyer)
}
|
go
|
func RegisterSourceAsSchema(name string, source Source) error {
// Since registry is a global, lets first lock that.
registryMu.Lock()
defer registryMu.Unlock()
s := NewSchemaSource(name, source)
source.Init()
source.Setup(s)
if err := registry.SchemaAdd(s); err != nil {
return err
}
return discoverSchemaFromSource(s, registry.applyer)
}
|
[
"func",
"RegisterSourceAsSchema",
"(",
"name",
"string",
",",
"source",
"Source",
")",
"error",
"{",
"// Since registry is a global, lets first lock that.",
"registryMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"registryMu",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
":=",
"NewSchemaSource",
"(",
"name",
",",
"source",
")",
"\n",
"source",
".",
"Init",
"(",
")",
"\n",
"source",
".",
"Setup",
"(",
"s",
")",
"\n",
"if",
"err",
":=",
"registry",
".",
"SchemaAdd",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"discoverSchemaFromSource",
"(",
"s",
",",
"registry",
".",
"applyer",
")",
"\n",
"}"
] |
// RegisterSourceAsSchema means you have a datasource, that is going to act
// as a named schema. ie, this will not be a nested schema with sub-schemas
// and the source will not be re-useable as a source-type.
|
[
"RegisterSourceAsSchema",
"means",
"you",
"have",
"a",
"datasource",
"that",
"is",
"going",
"to",
"act",
"as",
"a",
"named",
"schema",
".",
"ie",
"this",
"will",
"not",
"be",
"a",
"nested",
"schema",
"with",
"sub",
"-",
"schemas",
"and",
"the",
"source",
"will",
"not",
"be",
"re",
"-",
"useable",
"as",
"a",
"source",
"-",
"type",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L71-L84
|
20,633
|
araddon/qlbridge
|
schema/registry.go
|
RegisterSchema
|
func RegisterSchema(schema *Schema) error {
registryMu.Lock()
defer registryMu.Unlock()
return registry.SchemaAdd(schema)
}
|
go
|
func RegisterSchema(schema *Schema) error {
registryMu.Lock()
defer registryMu.Unlock()
return registry.SchemaAdd(schema)
}
|
[
"func",
"RegisterSchema",
"(",
"schema",
"*",
"Schema",
")",
"error",
"{",
"registryMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"registryMu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"registry",
".",
"SchemaAdd",
"(",
"schema",
")",
"\n",
"}"
] |
// RegisterSchema makes a named schema available by the provided @name
// If Register is called twice with the same name or if source is nil, it panics.
//
// Sources are specific schemas of type csv, elasticsearch, etc containing
// multiple tables.
|
[
"RegisterSchema",
"makes",
"a",
"named",
"schema",
"available",
"by",
"the",
"provided"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L91-L95
|
20,634
|
araddon/qlbridge
|
schema/registry.go
|
NewRegistry
|
func NewRegistry(applyer Applyer) *Registry {
return &Registry{
applyer: applyer,
sources: make(map[string]Source),
schemas: make(map[string]*Schema),
schemaNames: make([]string, 0),
}
}
|
go
|
func NewRegistry(applyer Applyer) *Registry {
return &Registry{
applyer: applyer,
sources: make(map[string]Source),
schemas: make(map[string]*Schema),
schemaNames: make([]string, 0),
}
}
|
[
"func",
"NewRegistry",
"(",
"applyer",
"Applyer",
")",
"*",
"Registry",
"{",
"return",
"&",
"Registry",
"{",
"applyer",
":",
"applyer",
",",
"sources",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"Source",
")",
",",
"schemas",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Schema",
")",
",",
"schemaNames",
":",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
",",
"}",
"\n",
"}"
] |
// NewRegistry create schema registry.
|
[
"NewRegistry",
"create",
"schema",
"registry",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L104-L111
|
20,635
|
araddon/qlbridge
|
schema/registry.go
|
SchemaDrop
|
func (m *Registry) SchemaDrop(schema, name string, objectType lex.TokenType) error {
name = strings.ToLower(name)
switch objectType {
case lex.TokenSchema, lex.TokenSource:
m.mu.RLock()
s, ok := m.schemas[name]
m.mu.RUnlock()
if !ok {
return ErrNotFound
}
return m.applyer.Drop(s, s)
case lex.TokenTable:
m.mu.RLock()
s, ok := m.schemas[schema]
m.mu.RUnlock()
if !ok {
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)
}
|
go
|
func (m *Registry) SchemaDrop(schema, name string, objectType lex.TokenType) error {
name = strings.ToLower(name)
switch objectType {
case lex.TokenSchema, lex.TokenSource:
m.mu.RLock()
s, ok := m.schemas[name]
m.mu.RUnlock()
if !ok {
return ErrNotFound
}
return m.applyer.Drop(s, s)
case lex.TokenTable:
m.mu.RLock()
s, ok := m.schemas[schema]
m.mu.RUnlock()
if !ok {
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)
}
|
[
"func",
"(",
"m",
"*",
"Registry",
")",
"SchemaDrop",
"(",
"schema",
",",
"name",
"string",
",",
"objectType",
"lex",
".",
"TokenType",
")",
"error",
"{",
"name",
"=",
"strings",
".",
"ToLower",
"(",
"name",
")",
"\n",
"switch",
"objectType",
"{",
"case",
"lex",
".",
"TokenSchema",
",",
"lex",
".",
"TokenSource",
":",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"s",
",",
"ok",
":=",
"m",
".",
"schemas",
"[",
"name",
"]",
"\n",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrNotFound",
"\n",
"}",
"\n",
"return",
"m",
".",
"applyer",
".",
"Drop",
"(",
"s",
",",
"s",
")",
"\n",
"case",
"lex",
".",
"TokenTable",
":",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"s",
",",
"ok",
":=",
"m",
".",
"schemas",
"[",
"schema",
"]",
"\n",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrNotFound",
"\n",
"}",
"\n",
"t",
",",
"_",
":=",
"s",
".",
"Table",
"(",
"name",
")",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"ErrNotFound",
"\n",
"}",
"\n",
"return",
"m",
".",
"applyer",
".",
"Drop",
"(",
"s",
",",
"t",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"objectType",
")",
"\n",
"}"
] |
// SchemaDrop removes a schema
|
[
"SchemaDrop",
"removes",
"a",
"schema"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L129-L154
|
20,636
|
araddon/qlbridge
|
schema/registry.go
|
SchemaRefresh
|
func (m *Registry) SchemaRefresh(name string) error {
m.mu.RLock()
s, ok := m.schemas[name]
m.mu.RUnlock()
if !ok {
return ErrNotFound
}
return m.applyer.AddOrUpdateOnSchema(s, s)
}
|
go
|
func (m *Registry) SchemaRefresh(name string) error {
m.mu.RLock()
s, ok := m.schemas[name]
m.mu.RUnlock()
if !ok {
return ErrNotFound
}
return m.applyer.AddOrUpdateOnSchema(s, s)
}
|
[
"func",
"(",
"m",
"*",
"Registry",
")",
"SchemaRefresh",
"(",
"name",
"string",
")",
"error",
"{",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"s",
",",
"ok",
":=",
"m",
".",
"schemas",
"[",
"name",
"]",
"\n",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrNotFound",
"\n",
"}",
"\n",
"return",
"m",
".",
"applyer",
".",
"AddOrUpdateOnSchema",
"(",
"s",
",",
"s",
")",
"\n",
"}"
] |
// SchemaRefresh means reload the schema from underlying store. Possibly
// requires introspection.
|
[
"SchemaRefresh",
"means",
"reload",
"the",
"schema",
"from",
"underlying",
"store",
".",
"Possibly",
"requires",
"introspection",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L158-L166
|
20,637
|
araddon/qlbridge
|
schema/registry.go
|
SchemaAddFromConfig
|
func (m *Registry) SchemaAddFromConfig(conf *ConfigSource) error {
source, err := m.GetSource(conf.SourceType)
if err != nil {
u.Warnf("could not find source type %q \nregistry: %s", conf.SourceType, m.String())
return err
}
s := NewSchema(conf.Name)
s.Conf = conf
s.DS = source
if err := s.DS.Setup(s); err != nil {
u.Errorf("Error setuping up %+v err=%v", conf, err)
return err
}
// If we specify a parent schema to add this child schema to
if conf.Schema != "" && conf.Schema != 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.SchemaAdd(s)
}
|
go
|
func (m *Registry) SchemaAddFromConfig(conf *ConfigSource) error {
source, err := m.GetSource(conf.SourceType)
if err != nil {
u.Warnf("could not find source type %q \nregistry: %s", conf.SourceType, m.String())
return err
}
s := NewSchema(conf.Name)
s.Conf = conf
s.DS = source
if err := s.DS.Setup(s); err != nil {
u.Errorf("Error setuping up %+v err=%v", conf, err)
return err
}
// If we specify a parent schema to add this child schema to
if conf.Schema != "" && conf.Schema != 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.SchemaAdd(s)
}
|
[
"func",
"(",
"m",
"*",
"Registry",
")",
"SchemaAddFromConfig",
"(",
"conf",
"*",
"ConfigSource",
")",
"error",
"{",
"source",
",",
"err",
":=",
"m",
".",
"GetSource",
"(",
"conf",
".",
"SourceType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Warnf",
"(",
"\"",
"\\n",
"\"",
",",
"conf",
".",
"SourceType",
",",
"m",
".",
"String",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"s",
":=",
"NewSchema",
"(",
"conf",
".",
"Name",
")",
"\n",
"s",
".",
"Conf",
"=",
"conf",
"\n",
"s",
".",
"DS",
"=",
"source",
"\n",
"if",
"err",
":=",
"s",
".",
"DS",
".",
"Setup",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"conf",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// If we specify a parent schema to add this child schema to",
"if",
"conf",
".",
"Schema",
"!=",
"\"",
"\"",
"&&",
"conf",
".",
"Schema",
"!=",
"s",
".",
"Name",
"{",
"_",
",",
"ok",
":=",
"m",
".",
"Schema",
"(",
"conf",
".",
"Schema",
")",
"\n",
"if",
"!",
"ok",
"{",
"ps",
":=",
"NewSchema",
"(",
"conf",
".",
"Schema",
")",
"\n",
"err",
":=",
"m",
".",
"SchemaAdd",
"(",
"ps",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"=",
"m",
".",
"SchemaAddChild",
"(",
"conf",
".",
"Schema",
",",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"m",
".",
"SchemaAdd",
"(",
"s",
")",
"\n",
"}"
] |
// SchemaAddFromConfig means you have a Schema-Source you want to add
|
[
"SchemaAddFromConfig",
"means",
"you",
"have",
"a",
"Schema",
"-",
"Source",
"you",
"want",
"to",
"add"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L177-L211
|
20,638
|
araddon/qlbridge
|
schema/registry.go
|
Schema
|
func (m *Registry) Schema(schemaName string) (*Schema, bool) {
m.mu.RLock()
defer m.mu.RUnlock()
s, ok := m.schemas[schemaName]
return s, ok
}
|
go
|
func (m *Registry) Schema(schemaName string) (*Schema, bool) {
m.mu.RLock()
defer m.mu.RUnlock()
s, ok := m.schemas[schemaName]
return s, ok
}
|
[
"func",
"(",
"m",
"*",
"Registry",
")",
"Schema",
"(",
"schemaName",
"string",
")",
"(",
"*",
"Schema",
",",
"bool",
")",
"{",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"s",
",",
"ok",
":=",
"m",
".",
"schemas",
"[",
"schemaName",
"]",
"\n",
"return",
"s",
",",
"ok",
"\n",
"}"
] |
// Schema Get schema for given name.
|
[
"Schema",
"Get",
"schema",
"for",
"given",
"name",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L214-L219
|
20,639
|
araddon/qlbridge
|
schema/registry.go
|
SchemaAdd
|
func (m *Registry) SchemaAdd(s *Schema) error {
s.Name = strings.ToLower(s.Name)
m.mu.RLock()
_, ok := m.schemas[s.Name]
m.mu.RUnlock()
if ok {
if s.Name != "server_schema" {
u.Warnf("Can't add duplicate schema %q", s.Name)
}
return fmt.Errorf("Cannot add duplicate schema %q", s.Name)
}
if s.InfoSchema == nil {
s.InfoSchema = NewInfoSchema("schema", s)
}
m.applyer.AddOrUpdateOnSchema(s, s)
return nil
}
|
go
|
func (m *Registry) SchemaAdd(s *Schema) error {
s.Name = strings.ToLower(s.Name)
m.mu.RLock()
_, ok := m.schemas[s.Name]
m.mu.RUnlock()
if ok {
if s.Name != "server_schema" {
u.Warnf("Can't add duplicate schema %q", s.Name)
}
return fmt.Errorf("Cannot add duplicate schema %q", s.Name)
}
if s.InfoSchema == nil {
s.InfoSchema = NewInfoSchema("schema", s)
}
m.applyer.AddOrUpdateOnSchema(s, s)
return nil
}
|
[
"func",
"(",
"m",
"*",
"Registry",
")",
"SchemaAdd",
"(",
"s",
"*",
"Schema",
")",
"error",
"{",
"s",
".",
"Name",
"=",
"strings",
".",
"ToLower",
"(",
"s",
".",
"Name",
")",
"\n",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"_",
",",
"ok",
":=",
"m",
".",
"schemas",
"[",
"s",
".",
"Name",
"]",
"\n",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"ok",
"{",
"if",
"s",
".",
"Name",
"!=",
"\"",
"\"",
"{",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"s",
".",
"Name",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Name",
")",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"InfoSchema",
"==",
"nil",
"{",
"s",
".",
"InfoSchema",
"=",
"NewInfoSchema",
"(",
"\"",
"\"",
",",
"s",
")",
"\n",
"}",
"\n",
"m",
".",
"applyer",
".",
"AddOrUpdateOnSchema",
"(",
"s",
",",
"s",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SchemaAdd Add a new Schema
|
[
"SchemaAdd",
"Add",
"a",
"new",
"Schema"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L222-L240
|
20,640
|
araddon/qlbridge
|
schema/registry.go
|
SchemaAddChild
|
func (m *Registry) SchemaAddChild(name string, child *Schema) error {
name = strings.ToLower(name)
m.mu.RLock()
parent, ok := m.schemas[name]
m.mu.RUnlock()
if !ok {
return fmt.Errorf("Cannot find schema %q to add child", name)
}
m.applyer.AddOrUpdateOnSchema(parent, child)
return nil
}
|
go
|
func (m *Registry) SchemaAddChild(name string, child *Schema) error {
name = strings.ToLower(name)
m.mu.RLock()
parent, ok := m.schemas[name]
m.mu.RUnlock()
if !ok {
return fmt.Errorf("Cannot find schema %q to add child", name)
}
m.applyer.AddOrUpdateOnSchema(parent, child)
return nil
}
|
[
"func",
"(",
"m",
"*",
"Registry",
")",
"SchemaAddChild",
"(",
"name",
"string",
",",
"child",
"*",
"Schema",
")",
"error",
"{",
"name",
"=",
"strings",
".",
"ToLower",
"(",
"name",
")",
"\n",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"parent",
",",
"ok",
":=",
"m",
".",
"schemas",
"[",
"name",
"]",
"\n",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"m",
".",
"applyer",
".",
"AddOrUpdateOnSchema",
"(",
"parent",
",",
"child",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SchemaAddChild Add a new Child Schema
|
[
"SchemaAddChild",
"Add",
"a",
"new",
"Child",
"Schema"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L243-L253
|
20,641
|
araddon/qlbridge
|
schema/registry.go
|
GetSource
|
func (m *Registry) GetSource(sourceType string) (Source, error) {
return m.getDepth(0, sourceType)
}
|
go
|
func (m *Registry) GetSource(sourceType string) (Source, error) {
return m.getDepth(0, sourceType)
}
|
[
"func",
"(",
"m",
"*",
"Registry",
")",
"GetSource",
"(",
"sourceType",
"string",
")",
"(",
"Source",
",",
"error",
")",
"{",
"return",
"m",
".",
"getDepth",
"(",
"0",
",",
"sourceType",
")",
"\n",
"}"
] |
// GetSource Find a DataSource by SourceType
|
[
"GetSource",
"Find",
"a",
"DataSource",
"by",
"SourceType"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L261-L263
|
20,642
|
araddon/qlbridge
|
schema/registry.go
|
String
|
func (m *Registry) String() string {
m.mu.RLock()
defer m.mu.RUnlock()
sourceNames := make([]string, 0, len(m.sources))
for source := range m.sources {
sourceNames = append(sourceNames, source)
}
schemas := make([]string, 0, len(m.schemas))
for _, sch := range m.schemas {
schemas = append(schemas, sch.Name)
}
return fmt.Sprintf("{Sources: [%s] , Schemas: [%s]}", strings.Join(sourceNames, ", "), strings.Join(schemas, ", "))
}
|
go
|
func (m *Registry) String() string {
m.mu.RLock()
defer m.mu.RUnlock()
sourceNames := make([]string, 0, len(m.sources))
for source := range m.sources {
sourceNames = append(sourceNames, source)
}
schemas := make([]string, 0, len(m.schemas))
for _, sch := range m.schemas {
schemas = append(schemas, sch.Name)
}
return fmt.Sprintf("{Sources: [%s] , Schemas: [%s]}", strings.Join(sourceNames, ", "), strings.Join(schemas, ", "))
}
|
[
"func",
"(",
"m",
"*",
"Registry",
")",
"String",
"(",
")",
"string",
"{",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"sourceNames",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"m",
".",
"sources",
")",
")",
"\n",
"for",
"source",
":=",
"range",
"m",
".",
"sources",
"{",
"sourceNames",
"=",
"append",
"(",
"sourceNames",
",",
"source",
")",
"\n",
"}",
"\n",
"schemas",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"m",
".",
"schemas",
")",
")",
"\n",
"for",
"_",
",",
"sch",
":=",
"range",
"m",
".",
"schemas",
"{",
"schemas",
"=",
"append",
"(",
"schemas",
",",
"sch",
".",
"Name",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"sourceNames",
",",
"\"",
"\"",
")",
",",
"strings",
".",
"Join",
"(",
"schemas",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// String describe contents of registry.
|
[
"String",
"describe",
"contents",
"of",
"registry",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L280-L292
|
20,643
|
araddon/qlbridge
|
schema/registry.go
|
discoverSchemaFromSource
|
func discoverSchemaFromSource(s *Schema, applyer Applyer) error {
if s.DS == nil {
return fmt.Errorf("Missing datasource for schema %q", s.Name)
}
if s.InfoSchema == nil {
return fmt.Errorf("Missing InfoSchema for schema %q", s.Name)
}
if err := s.DS.Setup(s); err != nil {
u.Errorf("Error setting up %v %v", s.Name, err)
return err
}
// For each table in source schema
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
}
|
go
|
func discoverSchemaFromSource(s *Schema, applyer Applyer) error {
if s.DS == nil {
return fmt.Errorf("Missing datasource for schema %q", s.Name)
}
if s.InfoSchema == nil {
return fmt.Errorf("Missing InfoSchema for schema %q", s.Name)
}
if err := s.DS.Setup(s); err != nil {
u.Errorf("Error setting up %v %v", s.Name, err)
return err
}
// For each table in source schema
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
}
|
[
"func",
"discoverSchemaFromSource",
"(",
"s",
"*",
"Schema",
",",
"applyer",
"Applyer",
")",
"error",
"{",
"if",
"s",
".",
"DS",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Name",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"InfoSchema",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Name",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"s",
".",
"DS",
".",
"Setup",
"(",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
".",
"Name",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// For each table in source schema",
"for",
"_",
",",
"tableName",
":=",
"range",
"s",
".",
"Tables",
"(",
")",
"{",
"tbl",
",",
"err",
":=",
"s",
".",
"Table",
"(",
"tableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"tbl",
"==",
"nil",
"{",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"tableName",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"applyer",
".",
"AddOrUpdateOnSchema",
"(",
"s",
",",
"tbl",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Create a schema from given named source
// we will find Source for that name and introspect
|
[
"Create",
"a",
"schema",
"from",
"given",
"named",
"source",
"we",
"will",
"find",
"Source",
"for",
"that",
"name",
"and",
"introspect"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/registry.go#L296-L321
|
20,644
|
araddon/qlbridge
|
rel/filter.go
|
String
|
func (m *FilterStatement) String() string {
if m == nil {
return ""
}
w := expr.NewJSONDialectWriter()
m.WriteDialect(w)
return w.String()
}
|
go
|
func (m *FilterStatement) String() string {
if m == nil {
return ""
}
w := expr.NewJSONDialectWriter()
m.WriteDialect(w)
return w.String()
}
|
[
"func",
"(",
"m",
"*",
"FilterStatement",
")",
"String",
"(",
")",
"string",
"{",
"if",
"m",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"w",
":=",
"expr",
".",
"NewJSONDialectWriter",
"(",
")",
"\n",
"m",
".",
"WriteDialect",
"(",
"w",
")",
"\n",
"return",
"w",
".",
"String",
"(",
")",
"\n",
"}"
] |
// String representation of FilterStatement
|
[
"String",
"representation",
"of",
"FilterStatement"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/filter.go#L86-L93
|
20,645
|
araddon/qlbridge
|
rel/filter.go
|
Includes
|
func (m *FilterStatement) Includes() []string {
if !m.checkedIncludes {
m.includes = expr.FindIncludes(m.Filter)
m.checkedIncludes = true
}
return m.includes
}
|
go
|
func (m *FilterStatement) Includes() []string {
if !m.checkedIncludes {
m.includes = expr.FindIncludes(m.Filter)
m.checkedIncludes = true
}
return m.includes
}
|
[
"func",
"(",
"m",
"*",
"FilterStatement",
")",
"Includes",
"(",
")",
"[",
"]",
"string",
"{",
"if",
"!",
"m",
".",
"checkedIncludes",
"{",
"m",
".",
"includes",
"=",
"expr",
".",
"FindIncludes",
"(",
"m",
".",
"Filter",
")",
"\n",
"m",
".",
"checkedIncludes",
"=",
"true",
"\n",
"}",
"\n",
"return",
"m",
".",
"includes",
"\n",
"}"
] |
// Includes Recurse this statement and find all includes
|
[
"Includes",
"Recurse",
"this",
"statement",
"and",
"find",
"all",
"includes"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/filter.go#L105-L111
|
20,646
|
araddon/qlbridge
|
rel/filter.go
|
String
|
func (m *FilterSelect) String() string {
if m == nil {
return ""
}
w := expr.NewDefaultWriter()
m.WriteDialect(w)
return w.String()
}
|
go
|
func (m *FilterSelect) String() string {
if m == nil {
return ""
}
w := expr.NewDefaultWriter()
m.WriteDialect(w)
return w.String()
}
|
[
"func",
"(",
"m",
"*",
"FilterSelect",
")",
"String",
"(",
")",
"string",
"{",
"if",
"m",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"w",
":=",
"expr",
".",
"NewDefaultWriter",
"(",
")",
"\n",
"m",
".",
"WriteDialect",
"(",
"w",
")",
"\n",
"return",
"w",
".",
"String",
"(",
")",
"\n",
"}"
] |
// String representation of FilterSelect
|
[
"String",
"representation",
"of",
"FilterSelect"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/filter.go#L189-L196
|
20,647
|
araddon/qlbridge
|
rel/filter.go
|
Equal
|
func (m *FilterSelect) Equal(s *FilterSelect) bool {
if m == nil && s == nil {
return true
}
if m == nil && s != nil {
return false
}
if m != nil && s == nil {
return false
}
if !m.Columns.Equal(s.Columns) {
return false
}
mfs := m.FilterStatement
if mfs != nil {
sfs := s.FilterStatement
if !mfs.Equal(sfs) {
return false
}
}
return true
}
|
go
|
func (m *FilterSelect) Equal(s *FilterSelect) bool {
if m == nil && s == nil {
return true
}
if m == nil && s != nil {
return false
}
if m != nil && s == nil {
return false
}
if !m.Columns.Equal(s.Columns) {
return false
}
mfs := m.FilterStatement
if mfs != nil {
sfs := s.FilterStatement
if !mfs.Equal(sfs) {
return false
}
}
return true
}
|
[
"func",
"(",
"m",
"*",
"FilterSelect",
")",
"Equal",
"(",
"s",
"*",
"FilterSelect",
")",
"bool",
"{",
"if",
"m",
"==",
"nil",
"&&",
"s",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"m",
"==",
"nil",
"&&",
"s",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"m",
"!=",
"nil",
"&&",
"s",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"m",
".",
"Columns",
".",
"Equal",
"(",
"s",
".",
"Columns",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"mfs",
":=",
"m",
".",
"FilterStatement",
"\n",
"if",
"mfs",
"!=",
"nil",
"{",
"sfs",
":=",
"s",
".",
"FilterStatement",
"\n",
"if",
"!",
"mfs",
".",
"Equal",
"(",
"sfs",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// Equal Checks for deep equality
|
[
"Equal",
"Checks",
"for",
"deep",
"equality"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/filter.go#L208-L229
|
20,648
|
araddon/qlbridge
|
datasource/sqlite/conn.go
|
Close
|
func (m *qryconn) Close() error {
defer m.source.mu.Unlock()
delete(m.source.qryconns, m.tbl.Name)
if m.rows != nil {
if err := m.rows.Close(); err != nil {
return err
}
}
return nil
}
|
go
|
func (m *qryconn) Close() error {
defer m.source.mu.Unlock()
delete(m.source.qryconns, m.tbl.Name)
if m.rows != nil {
if err := m.rows.Close(); err != nil {
return err
}
}
return nil
}
|
[
"func",
"(",
"m",
"*",
"qryconn",
")",
"Close",
"(",
")",
"error",
"{",
"defer",
"m",
".",
"source",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"m",
".",
"source",
".",
"qryconns",
",",
"m",
".",
"tbl",
".",
"Name",
")",
"\n",
"if",
"m",
".",
"rows",
"!=",
"nil",
"{",
"if",
"err",
":=",
"m",
".",
"rows",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close the qryconn. Since sqlite is a NON-threadsafe db, this is very important
// as we actually hold a lock per-table during scans to prevent conflict.
|
[
"Close",
"the",
"qryconn",
".",
"Since",
"sqlite",
"is",
"a",
"NON",
"-",
"threadsafe",
"db",
"this",
"is",
"very",
"important",
"as",
"we",
"actually",
"hold",
"a",
"lock",
"per",
"-",
"table",
"during",
"scans",
"to",
"prevent",
"conflict",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/sqlite/conn.go#L81-L90
|
20,649
|
araddon/qlbridge
|
datasource/sqlite/conn.go
|
Get
|
func (m *qryconn) Get(key driver.Value) (schema.Message, error) {
row := m.source.db.QueryRow(fmt.Sprintf("SELECT * FROM %v WHERE %s = $1", m.tbl.Name, m.cols[0]), key)
vals := make([]driver.Value, len(m.cols))
if err := row.Scan(&vals); err != nil {
return nil, err
}
return datasource.NewSqlDriverMessageMap(0, vals, m.colidx), nil
}
|
go
|
func (m *qryconn) Get(key driver.Value) (schema.Message, error) {
row := m.source.db.QueryRow(fmt.Sprintf("SELECT * FROM %v WHERE %s = $1", m.tbl.Name, m.cols[0]), key)
vals := make([]driver.Value, len(m.cols))
if err := row.Scan(&vals); err != nil {
return nil, err
}
return datasource.NewSqlDriverMessageMap(0, vals, m.colidx), nil
}
|
[
"func",
"(",
"m",
"*",
"qryconn",
")",
"Get",
"(",
"key",
"driver",
".",
"Value",
")",
"(",
"schema",
".",
"Message",
",",
"error",
")",
"{",
"row",
":=",
"m",
".",
"source",
".",
"db",
".",
"QueryRow",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"tbl",
".",
"Name",
",",
"m",
".",
"cols",
"[",
"0",
"]",
")",
",",
"key",
")",
"\n",
"vals",
":=",
"make",
"(",
"[",
"]",
"driver",
".",
"Value",
",",
"len",
"(",
"m",
".",
"cols",
")",
")",
"\n",
"if",
"err",
":=",
"row",
".",
"Scan",
"(",
"&",
"vals",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"datasource",
".",
"NewSqlDriverMessageMap",
"(",
"0",
",",
"vals",
",",
"m",
".",
"colidx",
")",
",",
"nil",
"\n",
"}"
] |
// Get a single row by key.
|
[
"Get",
"a",
"single",
"row",
"by",
"key",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/sqlite/conn.go#L216-L224
|
20,650
|
araddon/qlbridge
|
datasource/sqlite/conn.go
|
Delete
|
func (m *qryconn) Delete(key driver.Value) (int, error) {
return -1, schema.ErrNotImplemented
}
|
go
|
func (m *qryconn) Delete(key driver.Value) (int, error) {
return -1, schema.ErrNotImplemented
}
|
[
"func",
"(",
"m",
"*",
"qryconn",
")",
"Delete",
"(",
"key",
"driver",
".",
"Value",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"-",
"1",
",",
"schema",
".",
"ErrNotImplemented",
"\n",
"}"
] |
// Delete deletes a single row by key
|
[
"Delete",
"deletes",
"a",
"single",
"row",
"by",
"key"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/sqlite/conn.go#L227-L229
|
20,651
|
araddon/qlbridge
|
datasource/sqlite/conn.go
|
WalkSourceSelect
|
func (m *qryconn) WalkSourceSelect(planner plan.Planner, p *plan.Source) (plan.Task, error) {
sqlSelect := p.Stmt.Source
u.Infof("original %s", sqlSelect.String())
p.Stmt.Source = nil
p.Stmt.Rewrite(sqlSelect)
sqlSelect = p.Stmt.Source
u.Infof("original after From(source) rewrite %s", sqlSelect.String())
sqlSelect.RewriteAsRawSelect()
m.cols = sqlSelect.Columns.UnAliasedFieldNames()
m.colidx = sqlSelect.ColIndexes()
sqlString, _ := newRewriter(sqlSelect).rewrite()
u.Infof("after sqlite-rewrite %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, nil
}
|
go
|
func (m *qryconn) WalkSourceSelect(planner plan.Planner, p *plan.Source) (plan.Task, error) {
sqlSelect := p.Stmt.Source
u.Infof("original %s", sqlSelect.String())
p.Stmt.Source = nil
p.Stmt.Rewrite(sqlSelect)
sqlSelect = p.Stmt.Source
u.Infof("original after From(source) rewrite %s", sqlSelect.String())
sqlSelect.RewriteAsRawSelect()
m.cols = sqlSelect.Columns.UnAliasedFieldNames()
m.colidx = sqlSelect.ColIndexes()
sqlString, _ := newRewriter(sqlSelect).rewrite()
u.Infof("after sqlite-rewrite %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, nil
}
|
[
"func",
"(",
"m",
"*",
"qryconn",
")",
"WalkSourceSelect",
"(",
"planner",
"plan",
".",
"Planner",
",",
"p",
"*",
"plan",
".",
"Source",
")",
"(",
"plan",
".",
"Task",
",",
"error",
")",
"{",
"sqlSelect",
":=",
"p",
".",
"Stmt",
".",
"Source",
"\n",
"u",
".",
"Infof",
"(",
"\"",
"\"",
",",
"sqlSelect",
".",
"String",
"(",
")",
")",
"\n",
"p",
".",
"Stmt",
".",
"Source",
"=",
"nil",
"\n",
"p",
".",
"Stmt",
".",
"Rewrite",
"(",
"sqlSelect",
")",
"\n",
"sqlSelect",
"=",
"p",
".",
"Stmt",
".",
"Source",
"\n",
"u",
".",
"Infof",
"(",
"\"",
"\"",
",",
"sqlSelect",
".",
"String",
"(",
")",
")",
"\n",
"sqlSelect",
".",
"RewriteAsRawSelect",
"(",
")",
"\n\n",
"m",
".",
"cols",
"=",
"sqlSelect",
".",
"Columns",
".",
"UnAliasedFieldNames",
"(",
")",
"\n",
"m",
".",
"colidx",
"=",
"sqlSelect",
".",
"ColIndexes",
"(",
")",
"\n",
"sqlString",
",",
"_",
":=",
"newRewriter",
"(",
"sqlSelect",
")",
".",
"rewrite",
"(",
")",
"\n\n",
"u",
".",
"Infof",
"(",
"\"",
"\"",
",",
"sqlSelect",
".",
"String",
"(",
")",
")",
"\n",
"u",
".",
"Infof",
"(",
"\"",
"\"",
",",
"sqlString",
")",
"\n\n",
"rows",
",",
"err",
":=",
"m",
".",
"source",
".",
"db",
".",
"Query",
"(",
"sqlString",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
".",
"rows",
"=",
"rows",
"\n",
"m",
".",
"TaskBase",
"=",
"exec",
".",
"NewTaskBase",
"(",
"p",
".",
"Context",
"(",
")",
")",
"\n",
"p",
".",
"SourceExec",
"=",
"true",
"\n",
"m",
".",
"ps",
"=",
"p",
"\n",
"//p.Complete = true",
"return",
"nil",
",",
"nil",
"\n",
"}"
] |
// WalkSourceSelect An interface implemented by this connection allowing the planner
// to push down as much sql logic down to sqlite.
|
[
"WalkSourceSelect",
"An",
"interface",
"implemented",
"by",
"this",
"connection",
"allowing",
"the",
"planner",
"to",
"push",
"down",
"as",
"much",
"sql",
"logic",
"down",
"to",
"sqlite",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/sqlite/conn.go#L233-L261
|
20,652
|
araddon/qlbridge
|
exec/projection.go
|
Close
|
func (m *Projection) Close() error {
//u.Debugf("Projection Close alreadyclosed?%v", m.closed)
m.Lock()
if m.closed {
m.Unlock()
return nil
}
m.closed = true
m.Unlock()
go m.drain()
//return m.TaskBase.Close()
return nil
}
|
go
|
func (m *Projection) Close() error {
//u.Debugf("Projection Close alreadyclosed?%v", m.closed)
m.Lock()
if m.closed {
m.Unlock()
return nil
}
m.closed = true
m.Unlock()
go m.drain()
//return m.TaskBase.Close()
return nil
}
|
[
"func",
"(",
"m",
"*",
"Projection",
")",
"Close",
"(",
")",
"error",
"{",
"//u.Debugf(\"Projection Close alreadyclosed?%v\", m.closed)",
"m",
".",
"Lock",
"(",
")",
"\n",
"if",
"m",
".",
"closed",
"{",
"m",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"m",
".",
"closed",
"=",
"true",
"\n",
"m",
".",
"Unlock",
"(",
")",
"\n\n",
"go",
"m",
".",
"drain",
"(",
")",
"\n\n",
"//return m.TaskBase.Close()",
"return",
"nil",
"\n",
"}"
] |
// Close cleans up and closes channels
|
[
"Close",
"cleans",
"up",
"and",
"closes",
"channels"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/projection.go#L84-L98
|
20,653
|
araddon/qlbridge
|
exec/projection.go
|
CloseFinal
|
func (m *Projection) CloseFinal() error {
//u.Debugf("Projection CloseFinal alreadyclosed?%v", m.closed)
defer func() {
if r := recover(); r != nil {
u.Warnf("error on close %v", r)
}
}()
//return nil
return m.TaskBase.Close()
}
|
go
|
func (m *Projection) CloseFinal() error {
//u.Debugf("Projection CloseFinal alreadyclosed?%v", m.closed)
defer func() {
if r := recover(); r != nil {
u.Warnf("error on close %v", r)
}
}()
//return nil
return m.TaskBase.Close()
}
|
[
"func",
"(",
"m",
"*",
"Projection",
")",
"CloseFinal",
"(",
")",
"error",
"{",
"//u.Debugf(\"Projection CloseFinal alreadyclosed?%v\", m.closed)",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"//return nil",
"return",
"m",
".",
"TaskBase",
".",
"Close",
"(",
")",
"\n",
"}"
] |
// CloseFinal after exit, cleanup some more
|
[
"CloseFinal",
"after",
"exit",
"cleanup",
"some",
"more"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/projection.go#L101-L110
|
20,654
|
araddon/qlbridge
|
exec/projection.go
|
limitEvaluator
|
func (m *Projection) limitEvaluator() MessageHandler {
out := m.MessageOut()
limit := m.p.Stmt.Limit
if limit == 0 {
limit = math.MaxInt32
}
rowCt := 0
return func(ctx *plan.Context, msg schema.Message) bool {
select {
case <-m.SigChan():
u.Debugf("%p closed, returning", m)
return false
default:
}
if rowCt >= limit {
if rowCt == limit {
//u.Debugf("%p Projection reaching Limit!!! rowct:%v 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
}
}
}
|
go
|
func (m *Projection) limitEvaluator() MessageHandler {
out := m.MessageOut()
limit := m.p.Stmt.Limit
if limit == 0 {
limit = math.MaxInt32
}
rowCt := 0
return func(ctx *plan.Context, msg schema.Message) bool {
select {
case <-m.SigChan():
u.Debugf("%p closed, returning", m)
return false
default:
}
if rowCt >= limit {
if rowCt == limit {
//u.Debugf("%p Projection reaching Limit!!! rowct:%v 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
}
}
}
|
[
"func",
"(",
"m",
"*",
"Projection",
")",
"limitEvaluator",
"(",
")",
"MessageHandler",
"{",
"out",
":=",
"m",
".",
"MessageOut",
"(",
")",
"\n",
"limit",
":=",
"m",
".",
"p",
".",
"Stmt",
".",
"Limit",
"\n",
"if",
"limit",
"==",
"0",
"{",
"limit",
"=",
"math",
".",
"MaxInt32",
"\n",
"}",
"\n\n",
"rowCt",
":=",
"0",
"\n",
"return",
"func",
"(",
"ctx",
"*",
"plan",
".",
"Context",
",",
"msg",
"schema",
".",
"Message",
")",
"bool",
"{",
"select",
"{",
"case",
"<-",
"m",
".",
"SigChan",
"(",
")",
":",
"u",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"return",
"false",
"\n",
"default",
":",
"}",
"\n\n",
"if",
"rowCt",
">=",
"limit",
"{",
"if",
"rowCt",
"==",
"limit",
"{",
"//u.Debugf(\"%p Projection reaching Limit!!! rowct:%v limit:%v\", m, rowCt, limit)",
"out",
"<-",
"nil",
"// Sending nil message is a message to downstream to shutdown",
"\n",
"//m.Close()",
"m",
".",
"Quit",
"(",
")",
"\n",
"}",
"\n",
"rowCt",
"++",
"\n",
"//return false",
"return",
"true",
"// swallow it",
"\n",
"}",
"\n",
"rowCt",
"++",
"\n\n",
"select",
"{",
"case",
"out",
"<-",
"msg",
":",
"return",
"true",
"\n",
"case",
"<-",
"m",
".",
"SigChan",
"(",
")",
":",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Limit only evaluator
|
[
"Limit",
"only",
"evaluator"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/projection.go#L315-L353
|
20,655
|
araddon/qlbridge
|
schema/schema.go
|
NewInfoSchema
|
func NewInfoSchema(schemaName string, s *Schema) *Schema {
is := NewSchemaSource(schemaName, nil)
is.InfoSchema = is
is.SchemaRef = s
return is
}
|
go
|
func NewInfoSchema(schemaName string, s *Schema) *Schema {
is := NewSchemaSource(schemaName, nil)
is.InfoSchema = is
is.SchemaRef = s
return is
}
|
[
"func",
"NewInfoSchema",
"(",
"schemaName",
"string",
",",
"s",
"*",
"Schema",
")",
"*",
"Schema",
"{",
"is",
":=",
"NewSchemaSource",
"(",
"schemaName",
",",
"nil",
")",
"\n",
"is",
".",
"InfoSchema",
"=",
"is",
"\n",
"is",
".",
"SchemaRef",
"=",
"s",
"\n",
"return",
"is",
"\n",
"}"
] |
// NewInfoSchema create a new empty schema with given name.
|
[
"NewInfoSchema",
"create",
"a",
"new",
"empty",
"schema",
"with",
"given",
"name",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L172-L177
|
20,656
|
araddon/qlbridge
|
schema/schema.go
|
NewSchemaSource
|
func NewSchemaSource(schemaName string, ds Source) *Schema {
m := &Schema{
Name: strings.ToLower(schemaName),
schemas: make(map[string]*Schema),
tableMap: make(map[string]*Table),
tableSchemas: make(map[string]*Schema),
tableNames: make([]string, 0),
DS: ds,
}
return m
}
|
go
|
func NewSchemaSource(schemaName string, ds Source) *Schema {
m := &Schema{
Name: strings.ToLower(schemaName),
schemas: make(map[string]*Schema),
tableMap: make(map[string]*Table),
tableSchemas: make(map[string]*Schema),
tableNames: make([]string, 0),
DS: ds,
}
return m
}
|
[
"func",
"NewSchemaSource",
"(",
"schemaName",
"string",
",",
"ds",
"Source",
")",
"*",
"Schema",
"{",
"m",
":=",
"&",
"Schema",
"{",
"Name",
":",
"strings",
".",
"ToLower",
"(",
"schemaName",
")",
",",
"schemas",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Schema",
")",
",",
"tableMap",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Table",
")",
",",
"tableSchemas",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Schema",
")",
",",
"tableNames",
":",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
",",
"DS",
":",
"ds",
",",
"}",
"\n",
"return",
"m",
"\n",
"}"
] |
// NewSchemaSource create a new empty schema with given name and source.
|
[
"NewSchemaSource",
"create",
"a",
"new",
"empty",
"schema",
"with",
"given",
"name",
"and",
"source",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L180-L190
|
20,657
|
araddon/qlbridge
|
schema/schema.go
|
Since
|
func (m *Schema) Since(dur time.Duration) bool {
if m.lastRefreshed.IsZero() {
return false
}
if m.lastRefreshed.After(time.Now().Add(dur)) {
return true
}
return false
}
|
go
|
func (m *Schema) Since(dur time.Duration) bool {
if m.lastRefreshed.IsZero() {
return false
}
if m.lastRefreshed.After(time.Now().Add(dur)) {
return true
}
return false
}
|
[
"func",
"(",
"m",
"*",
"Schema",
")",
"Since",
"(",
"dur",
"time",
".",
"Duration",
")",
"bool",
"{",
"if",
"m",
".",
"lastRefreshed",
".",
"IsZero",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"m",
".",
"lastRefreshed",
".",
"After",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"dur",
")",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// Since Is this schema object been refreshed within time window described by @dur time ago ?
|
[
"Since",
"Is",
"this",
"schema",
"object",
"been",
"refreshed",
"within",
"time",
"window",
"described",
"by"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L193-L201
|
20,658
|
araddon/qlbridge
|
schema/schema.go
|
Table
|
func (m *Schema) Table(tableIn string) (*Table, error) {
tableName := strings.ToLower(tableIn)
m.mu.RLock()
defer m.mu.RUnlock()
// u.Debugf("%p looking up %q", m, tableName)
tbl, ok := m.tableMap[tableName]
if ok && tbl != nil {
return tbl, nil
}
// Lets see if it is `schema`.`table` format
_, tableName, ok = expr.LeftRight(tableName)
if ok {
tbl, ok = 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)
}
|
go
|
func (m *Schema) Table(tableIn string) (*Table, error) {
tableName := strings.ToLower(tableIn)
m.mu.RLock()
defer m.mu.RUnlock()
// u.Debugf("%p looking up %q", m, tableName)
tbl, ok := m.tableMap[tableName]
if ok && tbl != nil {
return tbl, nil
}
// Lets see if it is `schema`.`table` format
_, tableName, ok = expr.LeftRight(tableName)
if ok {
tbl, ok = 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)
}
|
[
"func",
"(",
"m",
"*",
"Schema",
")",
"Table",
"(",
"tableIn",
"string",
")",
"(",
"*",
"Table",
",",
"error",
")",
"{",
"tableName",
":=",
"strings",
".",
"ToLower",
"(",
"tableIn",
")",
"\n\n",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"// u.Debugf(\"%p looking up %q\", m, tableName)",
"tbl",
",",
"ok",
":=",
"m",
".",
"tableMap",
"[",
"tableName",
"]",
"\n",
"if",
"ok",
"&&",
"tbl",
"!=",
"nil",
"{",
"return",
"tbl",
",",
"nil",
"\n",
"}",
"\n\n",
"// Lets see if it is `schema`.`table` format",
"_",
",",
"tableName",
",",
"ok",
"=",
"expr",
".",
"LeftRight",
"(",
"tableName",
")",
"\n",
"if",
"ok",
"{",
"tbl",
",",
"ok",
"=",
"m",
".",
"tableMap",
"[",
"tableName",
"]",
"\n",
"if",
"ok",
"&&",
"tbl",
"!=",
"nil",
"{",
"return",
"tbl",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"SchemaRef",
"!=",
"nil",
"{",
"return",
"m",
".",
"SchemaRef",
".",
"Table",
"(",
"tableIn",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tableIn",
")",
"\n",
"}"
] |
// Table gets Table definition for given table name
|
[
"Table",
"gets",
"Table",
"definition",
"for",
"given",
"table",
"name"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L210-L237
|
20,659
|
araddon/qlbridge
|
schema/schema.go
|
OpenConn
|
func (m *Schema) OpenConn(tableName string) (Conn, error) {
tableName = strings.ToLower(tableName)
m.mu.RLock()
defer m.mu.RUnlock()
sch, ok := m.tableSchemas[tableName]
if !ok || sch == nil || sch.DS == nil {
return nil, fmt.Errorf("Could not find a DataSource for that table %q", tableName)
}
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
}
|
go
|
func (m *Schema) OpenConn(tableName string) (Conn, error) {
tableName = strings.ToLower(tableName)
m.mu.RLock()
defer m.mu.RUnlock()
sch, ok := m.tableSchemas[tableName]
if !ok || sch == nil || sch.DS == nil {
return nil, fmt.Errorf("Could not find a DataSource for that table %q", tableName)
}
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
}
|
[
"func",
"(",
"m",
"*",
"Schema",
")",
"OpenConn",
"(",
"tableName",
"string",
")",
"(",
"Conn",
",",
"error",
")",
"{",
"tableName",
"=",
"strings",
".",
"ToLower",
"(",
"tableName",
")",
"\n",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"sch",
",",
"ok",
":=",
"m",
".",
"tableSchemas",
"[",
"tableName",
"]",
"\n",
"if",
"!",
"ok",
"||",
"sch",
"==",
"nil",
"||",
"sch",
".",
"DS",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tableName",
")",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"sch",
".",
"DS",
".",
"Open",
"(",
"tableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"conn",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tableName",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] |
// OpenConn get a connection from this schema by table name.
|
[
"OpenConn",
"get",
"a",
"connection",
"from",
"this",
"schema",
"by",
"table",
"name",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L240-L257
|
20,660
|
araddon/qlbridge
|
schema/schema.go
|
Schema
|
func (m *Schema) Schema(schemaName string) (*Schema, error) {
// We always lower-case schema names
schemaName = strings.ToLower(schemaName)
m.mu.RLock()
defer m.mu.RUnlock()
child, ok := m.schemas[schemaName]
if ok && child != nil && child.DS != nil {
return child, nil
}
return nil, fmt.Errorf("Could not find a Schema by that name %q", schemaName)
}
|
go
|
func (m *Schema) Schema(schemaName string) (*Schema, error) {
// We always lower-case schema names
schemaName = strings.ToLower(schemaName)
m.mu.RLock()
defer m.mu.RUnlock()
child, ok := m.schemas[schemaName]
if ok && child != nil && child.DS != nil {
return child, nil
}
return nil, fmt.Errorf("Could not find a Schema by that name %q", schemaName)
}
|
[
"func",
"(",
"m",
"*",
"Schema",
")",
"Schema",
"(",
"schemaName",
"string",
")",
"(",
"*",
"Schema",
",",
"error",
")",
"{",
"// We always lower-case schema names",
"schemaName",
"=",
"strings",
".",
"ToLower",
"(",
"schemaName",
")",
"\n",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"child",
",",
"ok",
":=",
"m",
".",
"schemas",
"[",
"schemaName",
"]",
"\n",
"if",
"ok",
"&&",
"child",
"!=",
"nil",
"&&",
"child",
".",
"DS",
"!=",
"nil",
"{",
"return",
"child",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"schemaName",
")",
"\n",
"}"
] |
// Schema Find a child Schema for given schema name,
|
[
"Schema",
"Find",
"a",
"child",
"Schema",
"for",
"given",
"schema",
"name"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L260-L270
|
20,661
|
araddon/qlbridge
|
schema/schema.go
|
SchemaForTable
|
func (m *Schema) SchemaForTable(tableName string) (*Schema, error) {
// We always lower-case table names
tableName = strings.ToLower(tableName)
if m.Name == "schema" {
return m, nil
}
m.mu.RLock()
ss, ok := m.tableSchemas[tableName]
m.mu.RUnlock()
if ok && 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
}
|
go
|
func (m *Schema) SchemaForTable(tableName string) (*Schema, error) {
// We always lower-case table names
tableName = strings.ToLower(tableName)
if m.Name == "schema" {
return m, nil
}
m.mu.RLock()
ss, ok := m.tableSchemas[tableName]
m.mu.RUnlock()
if ok && 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
}
|
[
"func",
"(",
"m",
"*",
"Schema",
")",
"SchemaForTable",
"(",
"tableName",
"string",
")",
"(",
"*",
"Schema",
",",
"error",
")",
"{",
"// We always lower-case table names",
"tableName",
"=",
"strings",
".",
"ToLower",
"(",
"tableName",
")",
"\n\n",
"if",
"m",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"m",
",",
"nil",
"\n",
"}",
"\n\n",
"m",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"ss",
",",
"ok",
":=",
"m",
".",
"tableSchemas",
"[",
"tableName",
"]",
"\n",
"m",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"ok",
"&&",
"ss",
"!=",
"nil",
"&&",
"ss",
".",
"DS",
"!=",
"nil",
"{",
"return",
"ss",
",",
"nil",
"\n",
"}",
"\n\n",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"m",
",",
"m",
".",
"Name",
",",
"tableName",
")",
"\n\n",
"return",
"nil",
",",
"ErrNotFound",
"\n",
"}"
] |
// SchemaForTable Find a Schema for given Table
|
[
"SchemaForTable",
"Find",
"a",
"Schema",
"for",
"given",
"Table"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L273-L292
|
20,662
|
araddon/qlbridge
|
schema/schema.go
|
addChildSchema
|
func (m *Schema) addChildSchema(child *Schema) {
m.mu.Lock()
defer m.mu.Unlock()
m.schemas[child.Name] = child
child.parent = m
child.mu.RLock()
defer child.mu.RUnlock()
for tableName, tbl := range child.tableMap {
m.tableSchemas[tableName] = child
m.tableMap[tableName] = tbl
}
}
|
go
|
func (m *Schema) addChildSchema(child *Schema) {
m.mu.Lock()
defer m.mu.Unlock()
m.schemas[child.Name] = child
child.parent = m
child.mu.RLock()
defer child.mu.RUnlock()
for tableName, tbl := range child.tableMap {
m.tableSchemas[tableName] = child
m.tableMap[tableName] = tbl
}
}
|
[
"func",
"(",
"m",
"*",
"Schema",
")",
"addChildSchema",
"(",
"child",
"*",
"Schema",
")",
"{",
"m",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"schemas",
"[",
"child",
".",
"Name",
"]",
"=",
"child",
"\n",
"child",
".",
"parent",
"=",
"m",
"\n",
"child",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"child",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"tableName",
",",
"tbl",
":=",
"range",
"child",
".",
"tableMap",
"{",
"m",
".",
"tableSchemas",
"[",
"tableName",
"]",
"=",
"child",
"\n",
"m",
".",
"tableMap",
"[",
"tableName",
"]",
"=",
"tbl",
"\n",
"}",
"\n",
"}"
] |
// addChildSchema add a child schema to this one. Schemas can be tree-in-nature
// with schema of multiple backend datasources being combined into parent Schema, but each
// child has their own unique defined schema.
|
[
"addChildSchema",
"add",
"a",
"child",
"schema",
"to",
"this",
"one",
".",
"Schemas",
"can",
"be",
"tree",
"-",
"in",
"-",
"nature",
"with",
"schema",
"of",
"multiple",
"backend",
"datasources",
"being",
"combined",
"into",
"parent",
"Schema",
"but",
"each",
"child",
"has",
"their",
"own",
"unique",
"defined",
"schema",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L297-L308
|
20,663
|
araddon/qlbridge
|
schema/schema.go
|
NewTable
|
func NewTable(table string) *Table {
tpb := TablePb{
Name: strings.ToLower(table),
NameOriginal: table,
}
t := &Table{
TablePb: tpb,
Fields: make([]*Field, 0),
FieldMap: make(map[string]*Field),
}
t.init(nil)
return t
}
|
go
|
func NewTable(table string) *Table {
tpb := TablePb{
Name: strings.ToLower(table),
NameOriginal: table,
}
t := &Table{
TablePb: tpb,
Fields: make([]*Field, 0),
FieldMap: make(map[string]*Field),
}
t.init(nil)
return t
}
|
[
"func",
"NewTable",
"(",
"table",
"string",
")",
"*",
"Table",
"{",
"tpb",
":=",
"TablePb",
"{",
"Name",
":",
"strings",
".",
"ToLower",
"(",
"table",
")",
",",
"NameOriginal",
":",
"table",
",",
"}",
"\n",
"t",
":=",
"&",
"Table",
"{",
"TablePb",
":",
"tpb",
",",
"Fields",
":",
"make",
"(",
"[",
"]",
"*",
"Field",
",",
"0",
")",
",",
"FieldMap",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Field",
")",
",",
"}",
"\n",
"t",
".",
"init",
"(",
"nil",
")",
"\n",
"return",
"t",
"\n",
"}"
] |
// NewTable create a new table for a schema.
|
[
"NewTable",
"create",
"a",
"new",
"table",
"for",
"a",
"schema",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L473-L485
|
20,664
|
araddon/qlbridge
|
schema/schema.go
|
FieldsAsMessages
|
func (m *Table) FieldsAsMessages() []Message {
msgs := make([]Message, len(m.Fields))
for i, f := range m.Fields {
msgs[i] = f
}
return msgs
}
|
go
|
func (m *Table) FieldsAsMessages() []Message {
msgs := make([]Message, len(m.Fields))
for i, f := range m.Fields {
msgs[i] = f
}
return msgs
}
|
[
"func",
"(",
"m",
"*",
"Table",
")",
"FieldsAsMessages",
"(",
")",
"[",
"]",
"Message",
"{",
"msgs",
":=",
"make",
"(",
"[",
"]",
"Message",
",",
"len",
"(",
"m",
".",
"Fields",
")",
")",
"\n",
"for",
"i",
",",
"f",
":=",
"range",
"m",
".",
"Fields",
"{",
"msgs",
"[",
"i",
"]",
"=",
"f",
"\n",
"}",
"\n",
"return",
"msgs",
"\n",
"}"
] |
// FieldsAsMessages get list of all fields as interface Message
// used in schema as sql "describe table"
|
[
"FieldsAsMessages",
"get",
"list",
"of",
"all",
"fields",
"as",
"interface",
"Message",
"used",
"in",
"schema",
"as",
"sql",
"describe",
"table"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L500-L506
|
20,665
|
araddon/qlbridge
|
schema/schema.go
|
AddField
|
func (m *Table) AddField(fld *Field) {
found := false
for i, curFld := range m.Fields {
if curFld.Name == fld.Name {
found = true
m.Fields[i] = fld
break
}
}
if !found {
fld.idx = uint64(len(m.Fields))
m.Fields = append(m.Fields, fld)
}
m.FieldMap[fld.Name] = fld
}
|
go
|
func (m *Table) AddField(fld *Field) {
found := false
for i, curFld := range m.Fields {
if curFld.Name == fld.Name {
found = true
m.Fields[i] = fld
break
}
}
if !found {
fld.idx = uint64(len(m.Fields))
m.Fields = append(m.Fields, fld)
}
m.FieldMap[fld.Name] = fld
}
|
[
"func",
"(",
"m",
"*",
"Table",
")",
"AddField",
"(",
"fld",
"*",
"Field",
")",
"{",
"found",
":=",
"false",
"\n",
"for",
"i",
",",
"curFld",
":=",
"range",
"m",
".",
"Fields",
"{",
"if",
"curFld",
".",
"Name",
"==",
"fld",
".",
"Name",
"{",
"found",
"=",
"true",
"\n",
"m",
".",
"Fields",
"[",
"i",
"]",
"=",
"fld",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"fld",
".",
"idx",
"=",
"uint64",
"(",
"len",
"(",
"m",
".",
"Fields",
")",
")",
"\n",
"m",
".",
"Fields",
"=",
"append",
"(",
"m",
".",
"Fields",
",",
"fld",
")",
"\n",
"}",
"\n",
"m",
".",
"FieldMap",
"[",
"fld",
".",
"Name",
"]",
"=",
"fld",
"\n",
"}"
] |
// AddField register a new field
|
[
"AddField",
"register",
"a",
"new",
"field"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L515-L529
|
20,666
|
araddon/qlbridge
|
schema/schema.go
|
AddFieldType
|
func (m *Table) AddFieldType(name string, valType value.ValueType) {
m.AddField(&Field{FieldPb: FieldPb{Type: uint32(valType), Name: name}})
}
|
go
|
func (m *Table) AddFieldType(name string, valType value.ValueType) {
m.AddField(&Field{FieldPb: FieldPb{Type: uint32(valType), Name: name}})
}
|
[
"func",
"(",
"m",
"*",
"Table",
")",
"AddFieldType",
"(",
"name",
"string",
",",
"valType",
"value",
".",
"ValueType",
")",
"{",
"m",
".",
"AddField",
"(",
"&",
"Field",
"{",
"FieldPb",
":",
"FieldPb",
"{",
"Type",
":",
"uint32",
"(",
"valType",
")",
",",
"Name",
":",
"name",
"}",
"}",
")",
"\n",
"}"
] |
// AddFieldType describe and register a new column
|
[
"AddFieldType",
"describe",
"and",
"register",
"a",
"new",
"column"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L532-L534
|
20,667
|
araddon/qlbridge
|
schema/schema.go
|
Column
|
func (m *Table) Column(col string) (value.ValueType, bool) {
f, ok := m.FieldMap[col]
if ok {
return f.ValueType(), true
}
f, ok = m.FieldMap[strings.ToLower(col)]
if ok {
return f.ValueType(), true
}
return value.UnknownType, false
}
|
go
|
func (m *Table) Column(col string) (value.ValueType, bool) {
f, ok := m.FieldMap[col]
if ok {
return f.ValueType(), true
}
f, ok = m.FieldMap[strings.ToLower(col)]
if ok {
return f.ValueType(), true
}
return value.UnknownType, false
}
|
[
"func",
"(",
"m",
"*",
"Table",
")",
"Column",
"(",
"col",
"string",
")",
"(",
"value",
".",
"ValueType",
",",
"bool",
")",
"{",
"f",
",",
"ok",
":=",
"m",
".",
"FieldMap",
"[",
"col",
"]",
"\n",
"if",
"ok",
"{",
"return",
"f",
".",
"ValueType",
"(",
")",
",",
"true",
"\n",
"}",
"\n",
"f",
",",
"ok",
"=",
"m",
".",
"FieldMap",
"[",
"strings",
".",
"ToLower",
"(",
"col",
")",
"]",
"\n",
"if",
"ok",
"{",
"return",
"f",
".",
"ValueType",
"(",
")",
",",
"true",
"\n",
"}",
"\n",
"return",
"value",
".",
"UnknownType",
",",
"false",
"\n",
"}"
] |
// Column get the Underlying data type.
|
[
"Column",
"get",
"the",
"Underlying",
"data",
"type",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L537-L547
|
20,668
|
araddon/qlbridge
|
schema/schema.go
|
SetColumns
|
func (m *Table) SetColumns(cols []string) {
m.FieldPositions = make(map[string]int, len(cols))
for idx, col := range cols {
//col = strings.ToLower(col)
m.FieldPositions[col] = idx
cols[idx] = col
}
m.cols = cols
}
|
go
|
func (m *Table) SetColumns(cols []string) {
m.FieldPositions = make(map[string]int, len(cols))
for idx, col := range cols {
//col = strings.ToLower(col)
m.FieldPositions[col] = idx
cols[idx] = col
}
m.cols = cols
}
|
[
"func",
"(",
"m",
"*",
"Table",
")",
"SetColumns",
"(",
"cols",
"[",
"]",
"string",
")",
"{",
"m",
".",
"FieldPositions",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
",",
"len",
"(",
"cols",
")",
")",
"\n",
"for",
"idx",
",",
"col",
":=",
"range",
"cols",
"{",
"//col = strings.ToLower(col)",
"m",
".",
"FieldPositions",
"[",
"col",
"]",
"=",
"idx",
"\n",
"cols",
"[",
"idx",
"]",
"=",
"col",
"\n",
"}",
"\n",
"m",
".",
"cols",
"=",
"cols",
"\n",
"}"
] |
// SetColumns Explicityly set column names.
|
[
"SetColumns",
"Explicityly",
"set",
"column",
"names",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L550-L558
|
20,669
|
araddon/qlbridge
|
schema/schema.go
|
SetColumnsFromFields
|
func (m *Table) SetColumnsFromFields() {
m.FieldPositions = make(map[string]int, len(m.Fields))
cols := make([]string, len(m.Fields))
for idx, f := range m.Fields {
col := strings.ToLower(f.Name)
m.FieldPositions[col] = idx
cols[idx] = col
}
m.cols = cols
}
|
go
|
func (m *Table) SetColumnsFromFields() {
m.FieldPositions = make(map[string]int, len(m.Fields))
cols := make([]string, len(m.Fields))
for idx, f := range m.Fields {
col := strings.ToLower(f.Name)
m.FieldPositions[col] = idx
cols[idx] = col
}
m.cols = cols
}
|
[
"func",
"(",
"m",
"*",
"Table",
")",
"SetColumnsFromFields",
"(",
")",
"{",
"m",
".",
"FieldPositions",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
",",
"len",
"(",
"m",
".",
"Fields",
")",
")",
"\n",
"cols",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"m",
".",
"Fields",
")",
")",
"\n",
"for",
"idx",
",",
"f",
":=",
"range",
"m",
".",
"Fields",
"{",
"col",
":=",
"strings",
".",
"ToLower",
"(",
"f",
".",
"Name",
")",
"\n",
"m",
".",
"FieldPositions",
"[",
"col",
"]",
"=",
"idx",
"\n",
"cols",
"[",
"idx",
"]",
"=",
"col",
"\n",
"}",
"\n",
"m",
".",
"cols",
"=",
"cols",
"\n",
"}"
] |
// SetColumnsFromFields Explicityly set column names from fields.
|
[
"SetColumnsFromFields",
"Explicityly",
"set",
"column",
"names",
"from",
"fields",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/schema/schema.go#L561-L570
|
20,670
|
araddon/qlbridge
|
datasource/mockcsv/mockcsv.go
|
Schema
|
func Schema() *schema.Schema {
if sch != nil {
return sch
}
if err := schema.RegisterSourceAsSchema(SchemaName, CsvGlobal); err != nil {
u.Errorf("Could not read schema %v", err)
return nil
}
sch, _ = schema.DefaultRegistry().Schema(SchemaName)
return sch
}
|
go
|
func Schema() *schema.Schema {
if sch != nil {
return sch
}
if err := schema.RegisterSourceAsSchema(SchemaName, CsvGlobal); err != nil {
u.Errorf("Could not read schema %v", err)
return nil
}
sch, _ = schema.DefaultRegistry().Schema(SchemaName)
return sch
}
|
[
"func",
"Schema",
"(",
")",
"*",
"schema",
".",
"Schema",
"{",
"if",
"sch",
"!=",
"nil",
"{",
"return",
"sch",
"\n",
"}",
"\n",
"if",
"err",
":=",
"schema",
".",
"RegisterSourceAsSchema",
"(",
"SchemaName",
",",
"CsvGlobal",
")",
";",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"sch",
",",
"_",
"=",
"schema",
".",
"DefaultRegistry",
"(",
")",
".",
"Schema",
"(",
"SchemaName",
")",
"\n",
"return",
"sch",
"\n",
"}"
] |
// Schema global accessor to the mockcsv schema
|
[
"Schema",
"global",
"accessor",
"to",
"the",
"mockcsv",
"schema"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/mockcsv/mockcsv.go#L37-L47
|
20,671
|
araddon/qlbridge
|
datasource/mockcsv/mockcsv.go
|
LoadTable
|
func LoadTable(schemaName, name, csvRaw string) {
CsvGlobal.CreateTable(name, csvRaw)
schema.DefaultRegistry().SchemaRefresh(SchemaName)
}
|
go
|
func LoadTable(schemaName, name, csvRaw string) {
CsvGlobal.CreateTable(name, csvRaw)
schema.DefaultRegistry().SchemaRefresh(SchemaName)
}
|
[
"func",
"LoadTable",
"(",
"schemaName",
",",
"name",
",",
"csvRaw",
"string",
")",
"{",
"CsvGlobal",
".",
"CreateTable",
"(",
"name",
",",
"csvRaw",
")",
"\n",
"schema",
".",
"DefaultRegistry",
"(",
")",
".",
"SchemaRefresh",
"(",
"SchemaName",
")",
"\n",
"}"
] |
// LoadTable MockCsv is used for mocking so has a global data source we can load data into
|
[
"LoadTable",
"MockCsv",
"is",
"used",
"for",
"mocking",
"so",
"has",
"a",
"global",
"data",
"source",
"we",
"can",
"load",
"data",
"into"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/mockcsv/mockcsv.go#L50-L53
|
20,672
|
araddon/qlbridge
|
datasource/mockcsv/mockcsv.go
|
New
|
func New() *Source {
return &Source{
tablenamelist: make([]string, 0),
raw: make(map[string]string),
tables: make(map[string]*membtree.StaticDataSource),
}
}
|
go
|
func New() *Source {
return &Source{
tablenamelist: make([]string, 0),
raw: make(map[string]string),
tables: make(map[string]*membtree.StaticDataSource),
}
}
|
[
"func",
"New",
"(",
")",
"*",
"Source",
"{",
"return",
"&",
"Source",
"{",
"tablenamelist",
":",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
",",
"raw",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"tables",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"membtree",
".",
"StaticDataSource",
")",
",",
"}",
"\n",
"}"
] |
// New create csv mock source.
|
[
"New",
"create",
"csv",
"mock",
"source",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/mockcsv/mockcsv.go#L70-L76
|
20,673
|
araddon/qlbridge
|
datasource/mockcsv/mockcsv.go
|
Setup
|
func (m *Source) Setup(s *schema.Schema) error {
m.s = s
return nil
}
|
go
|
func (m *Source) Setup(s *schema.Schema) error {
m.s = s
return nil
}
|
[
"func",
"(",
"m",
"*",
"Source",
")",
"Setup",
"(",
"s",
"*",
"schema",
".",
"Schema",
")",
"error",
"{",
"m",
".",
"s",
"=",
"s",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Setup accept schema
|
[
"Setup",
"accept",
"schema"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/mockcsv/mockcsv.go#L82-L85
|
20,674
|
araddon/qlbridge
|
datasource/mockcsv/mockcsv.go
|
DropTable
|
func (m *Source) DropTable(t string) error {
delete(m.raw, t)
delete(m.tables, t)
names := make([]string, 0, len(m.tables))
for tableName, _ := range m.raw {
names = append(names, tableName)
}
m.tablenamelist = names
return nil
}
|
go
|
func (m *Source) DropTable(t string) error {
delete(m.raw, t)
delete(m.tables, t)
names := make([]string, 0, len(m.tables))
for tableName, _ := range m.raw {
names = append(names, tableName)
}
m.tablenamelist = names
return nil
}
|
[
"func",
"(",
"m",
"*",
"Source",
")",
"DropTable",
"(",
"t",
"string",
")",
"error",
"{",
"delete",
"(",
"m",
".",
"raw",
",",
"t",
")",
"\n",
"delete",
"(",
"m",
".",
"tables",
",",
"t",
")",
"\n",
"names",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"m",
".",
"tables",
")",
")",
"\n",
"for",
"tableName",
",",
"_",
":=",
"range",
"m",
".",
"raw",
"{",
"names",
"=",
"append",
"(",
"names",
",",
"tableName",
")",
"\n",
"}",
"\n",
"m",
".",
"tablenamelist",
"=",
"names",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DropTable Drop table schema
|
[
"DropTable",
"Drop",
"table",
"schema"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/mockcsv/mockcsv.go#L88-L97
|
20,675
|
araddon/qlbridge
|
datasource/mockcsv/mockcsv.go
|
Open
|
func (m *Source) Open(tableName string) (schema.Conn, error) {
tableName = strings.ToLower(tableName)
if ds, ok := m.tables[tableName]; ok {
return &Table{StaticDataSource: ds}, nil
}
err := m.loadTable(tableName)
if err != nil {
u.Errorf("could not load table %q err=%v", tableName, err)
return nil, err
}
ds := m.tables[tableName]
return &Table{StaticDataSource: ds}, nil
}
|
go
|
func (m *Source) Open(tableName string) (schema.Conn, error) {
tableName = strings.ToLower(tableName)
if ds, ok := m.tables[tableName]; ok {
return &Table{StaticDataSource: ds}, nil
}
err := m.loadTable(tableName)
if err != nil {
u.Errorf("could not load table %q err=%v", tableName, err)
return nil, err
}
ds := m.tables[tableName]
return &Table{StaticDataSource: ds}, nil
}
|
[
"func",
"(",
"m",
"*",
"Source",
")",
"Open",
"(",
"tableName",
"string",
")",
"(",
"schema",
".",
"Conn",
",",
"error",
")",
"{",
"tableName",
"=",
"strings",
".",
"ToLower",
"(",
"tableName",
")",
"\n",
"if",
"ds",
",",
"ok",
":=",
"m",
".",
"tables",
"[",
"tableName",
"]",
";",
"ok",
"{",
"return",
"&",
"Table",
"{",
"StaticDataSource",
":",
"ds",
"}",
",",
"nil",
"\n",
"}",
"\n",
"err",
":=",
"m",
".",
"loadTable",
"(",
"tableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tableName",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ds",
":=",
"m",
".",
"tables",
"[",
"tableName",
"]",
"\n",
"return",
"&",
"Table",
"{",
"StaticDataSource",
":",
"ds",
"}",
",",
"nil",
"\n",
"}"
] |
// Open connection to given tablename.
|
[
"Open",
"connection",
"to",
"given",
"tablename",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/mockcsv/mockcsv.go#L100-L113
|
20,676
|
araddon/qlbridge
|
datasource/mockcsv/mockcsv.go
|
CreateTable
|
func (m *Source) CreateTable(tableName, csvRaw string) {
if _, exists := m.raw[tableName]; !exists {
m.tablenamelist = append(m.tablenamelist, tableName)
}
m.raw[tableName] = csvRaw
m.loadTable(tableName)
}
|
go
|
func (m *Source) CreateTable(tableName, csvRaw string) {
if _, exists := m.raw[tableName]; !exists {
m.tablenamelist = append(m.tablenamelist, tableName)
}
m.raw[tableName] = csvRaw
m.loadTable(tableName)
}
|
[
"func",
"(",
"m",
"*",
"Source",
")",
"CreateTable",
"(",
"tableName",
",",
"csvRaw",
"string",
")",
"{",
"if",
"_",
",",
"exists",
":=",
"m",
".",
"raw",
"[",
"tableName",
"]",
";",
"!",
"exists",
"{",
"m",
".",
"tablenamelist",
"=",
"append",
"(",
"m",
".",
"tablenamelist",
",",
"tableName",
")",
"\n",
"}",
"\n",
"m",
".",
"raw",
"[",
"tableName",
"]",
"=",
"csvRaw",
"\n",
"m",
".",
"loadTable",
"(",
"tableName",
")",
"\n",
"}"
] |
// CreateTable create a csv table in this source.
|
[
"CreateTable",
"create",
"a",
"csv",
"table",
"in",
"this",
"source",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/mockcsv/mockcsv.go#L187-L193
|
20,677
|
araddon/qlbridge
|
datasource/files/filesource.go
|
Setup
|
func (m *FileSource) Setup(ss *schema.Schema) error {
m.ss = ss
if err := m.init(); err != nil {
return err
}
if m.lastLoad.Before(time.Now().Add(-schemaRefreshInterval)) {
m.lastLoad = time.Now()
}
m.partitionCt = uint64(m.ss.Conf.PartitionCt)
m.partitionFunc = SipPartitioner
return nil
}
|
go
|
func (m *FileSource) Setup(ss *schema.Schema) error {
m.ss = ss
if err := m.init(); err != nil {
return err
}
if m.lastLoad.Before(time.Now().Add(-schemaRefreshInterval)) {
m.lastLoad = time.Now()
}
m.partitionCt = uint64(m.ss.Conf.PartitionCt)
m.partitionFunc = SipPartitioner
return nil
}
|
[
"func",
"(",
"m",
"*",
"FileSource",
")",
"Setup",
"(",
"ss",
"*",
"schema",
".",
"Schema",
")",
"error",
"{",
"m",
".",
"ss",
"=",
"ss",
"\n",
"if",
"err",
":=",
"m",
".",
"init",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"m",
".",
"lastLoad",
".",
"Before",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"-",
"schemaRefreshInterval",
")",
")",
"{",
"m",
".",
"lastLoad",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"\n",
"m",
".",
"partitionCt",
"=",
"uint64",
"(",
"m",
".",
"ss",
".",
"Conf",
".",
"PartitionCt",
")",
"\n\n",
"m",
".",
"partitionFunc",
"=",
"SipPartitioner",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Setup the filesource with schema info
|
[
"Setup",
"the",
"filesource",
"with",
"schema",
"info"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/files/filesource.go#L99-L111
|
20,678
|
araddon/qlbridge
|
datasource/files/filesource.go
|
Open
|
func (m *FileSource) Open(tableName string) (schema.Conn, error) {
//u.Debugf("Open(%q)", tableName)
if tableName == m.filesTable {
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
}
|
go
|
func (m *FileSource) Open(tableName string) (schema.Conn, error) {
//u.Debugf("Open(%q)", tableName)
if tableName == m.filesTable {
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
}
|
[
"func",
"(",
"m",
"*",
"FileSource",
")",
"Open",
"(",
"tableName",
"string",
")",
"(",
"schema",
".",
"Conn",
",",
"error",
")",
"{",
"//u.Debugf(\"Open(%q)\", tableName)",
"if",
"tableName",
"==",
"m",
".",
"filesTable",
"{",
"return",
"m",
".",
"fdb",
".",
"Open",
"(",
"tableName",
")",
"\n",
"}",
"\n",
"pg",
",",
"err",
":=",
"m",
".",
"createPager",
"(",
"tableName",
",",
"0",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"pg",
",",
"nil",
"\n",
"}"
] |
// Open a connection to given table, partition of Source interface
|
[
"Open",
"a",
"connection",
"to",
"given",
"table",
"partition",
"of",
"Source",
"interface"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/files/filesource.go#L114-L125
|
20,679
|
araddon/qlbridge
|
datasource/files/filesource.go
|
Table
|
func (m *FileSource) Table(tableName string) (*schema.Table, error) {
//u.Debugf("Table(%q) path:%v %#v", tableName, m.path, m.ss.Conf)
// We have a special table that is the list of all files
if m.filesTable == tableName {
return m.fdb.Table(tableName)
}
// Check cache for this table
t, ok := m.tableSchemas[tableName]
if ok {
return t, nil
}
var err error
// Its possible that the file handle implements schema handling
if schemaSource, hasSchema := m.fh.(schema.SourceTableSchema); hasSchema {
t, err = schemaSource.Table(tableName)
if err != nil {
u.Errorf("could not get %T table %q %v", schemaSource, tableName, err)
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[tableName] = t
//u.Debugf("%p Table(%q) cols=%v", m, tableName, t.Columns())
return t, nil
}
|
go
|
func (m *FileSource) Table(tableName string) (*schema.Table, error) {
//u.Debugf("Table(%q) path:%v %#v", tableName, m.path, m.ss.Conf)
// We have a special table that is the list of all files
if m.filesTable == tableName {
return m.fdb.Table(tableName)
}
// Check cache for this table
t, ok := m.tableSchemas[tableName]
if ok {
return t, nil
}
var err error
// Its possible that the file handle implements schema handling
if schemaSource, hasSchema := m.fh.(schema.SourceTableSchema); hasSchema {
t, err = schemaSource.Table(tableName)
if err != nil {
u.Errorf("could not get %T table %q %v", schemaSource, tableName, err)
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[tableName] = t
//u.Debugf("%p Table(%q) cols=%v", m, tableName, t.Columns())
return t, nil
}
|
[
"func",
"(",
"m",
"*",
"FileSource",
")",
"Table",
"(",
"tableName",
"string",
")",
"(",
"*",
"schema",
".",
"Table",
",",
"error",
")",
"{",
"//u.Debugf(\"Table(%q) path:%v %#v\", tableName, m.path, m.ss.Conf)",
"// We have a special table that is the list of all files",
"if",
"m",
".",
"filesTable",
"==",
"tableName",
"{",
"return",
"m",
".",
"fdb",
".",
"Table",
"(",
"tableName",
")",
"\n",
"}",
"\n\n",
"// Check cache for this table",
"t",
",",
"ok",
":=",
"m",
".",
"tableSchemas",
"[",
"tableName",
"]",
"\n",
"if",
"ok",
"{",
"return",
"t",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"// Its possible that the file handle implements schema handling",
"if",
"schemaSource",
",",
"hasSchema",
":=",
"m",
".",
"fh",
".",
"(",
"schema",
".",
"SourceTableSchema",
")",
";",
"hasSchema",
"{",
"t",
",",
"err",
"=",
"schemaSource",
".",
"Table",
"(",
"tableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"schemaSource",
",",
"tableName",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"}",
"else",
"{",
"// Source doesn't implement Schema Handling so we are going to get",
"// a scanner and introspect some rows",
"t",
",",
"err",
"=",
"m",
".",
"buildTable",
"(",
"tableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tableName",
")",
"\n",
"}",
"\n\n",
"m",
".",
"tableSchemas",
"[",
"tableName",
"]",
"=",
"t",
"\n",
"//u.Debugf(\"%p Table(%q) cols=%v\", m, tableName, t.Columns())",
"return",
"t",
",",
"nil",
"\n",
"}"
] |
// Table satisfys SourceSchema interface to get table schema for given table
|
[
"Table",
"satisfys",
"SourceSchema",
"interface",
"to",
"get",
"table",
"schema",
"for",
"given",
"table"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/files/filesource.go#L289-L330
|
20,680
|
araddon/qlbridge
|
datasource/key.go
|
KeyFromWhere
|
func KeyFromWhere(wh interface{}) schema.Key {
switch n := wh.(type) {
case *rel.SqlWhere:
return KeyFromWhere(n.Expr)
case *expr.BinaryNode:
if len(n.Args) != 2 {
u.Warnf("need more args? %#v", n.Args)
return nil
}
in, ok := n.Args[0].(*expr.IdentityNode)
if !ok {
u.Warnf("not identity? %T", n.Args[0])
return nil
}
// This only allows for identity = value
// NOT: identity = expr(identity, arg)
//
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)
}
return nil
}
|
go
|
func KeyFromWhere(wh interface{}) schema.Key {
switch n := wh.(type) {
case *rel.SqlWhere:
return KeyFromWhere(n.Expr)
case *expr.BinaryNode:
if len(n.Args) != 2 {
u.Warnf("need more args? %#v", n.Args)
return nil
}
in, ok := n.Args[0].(*expr.IdentityNode)
if !ok {
u.Warnf("not identity? %T", n.Args[0])
return nil
}
// This only allows for identity = value
// NOT: identity = expr(identity, arg)
//
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)
}
return nil
}
|
[
"func",
"KeyFromWhere",
"(",
"wh",
"interface",
"{",
"}",
")",
"schema",
".",
"Key",
"{",
"switch",
"n",
":=",
"wh",
".",
"(",
"type",
")",
"{",
"case",
"*",
"rel",
".",
"SqlWhere",
":",
"return",
"KeyFromWhere",
"(",
"n",
".",
"Expr",
")",
"\n",
"case",
"*",
"expr",
".",
"BinaryNode",
":",
"if",
"len",
"(",
"n",
".",
"Args",
")",
"!=",
"2",
"{",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"n",
".",
"Args",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"in",
",",
"ok",
":=",
"n",
".",
"Args",
"[",
"0",
"]",
".",
"(",
"*",
"expr",
".",
"IdentityNode",
")",
"\n",
"if",
"!",
"ok",
"{",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"n",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"// This only allows for identity = value",
"// NOT: identity = expr(identity, arg)",
"//",
"switch",
"valT",
":=",
"n",
".",
"Args",
"[",
"1",
"]",
".",
"(",
"type",
")",
"{",
"case",
"*",
"expr",
".",
"NumberNode",
":",
"return",
"NewKeyCol",
"(",
"in",
".",
"Text",
",",
"valT",
".",
"Float64",
")",
"\n",
"case",
"*",
"expr",
".",
"StringNode",
":",
"return",
"NewKeyCol",
"(",
"in",
".",
"Text",
",",
"valT",
".",
"Text",
")",
"\n",
"//case *expr.FuncNode:",
"default",
":",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"valT",
")",
"\n",
"}",
"\n",
"default",
":",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"n",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Given a Where expression, lets try to create a key which
// requires form `idenity = "value"`
//
|
[
"Given",
"a",
"Where",
"expression",
"lets",
"try",
"to",
"create",
"a",
"key",
"which",
"requires",
"form",
"idenity",
"=",
"value"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/key.go#L47-L77
|
20,681
|
araddon/qlbridge
|
vm/_archive/vm_sql.go
|
NewSqlVm
|
func NewSqlVm(sqlText string) (*SqlVm, error) {
stmt, err := expr.ParseSqlVm(sqlText)
if err != nil {
return nil, err
}
m := &SqlVm{
Statement: stmt,
}
switch v := stmt.(type) {
case *expr.SqlSelect:
m.Keyword = lex.TokenSelect
m.sel = v
case *expr.SqlInsert:
m.Keyword = lex.TokenInsert
m.ins = v
case *expr.SqlDelete:
m.Keyword = lex.TokenDelete
m.del = v
}
return m, nil
}
|
go
|
func NewSqlVm(sqlText string) (*SqlVm, error) {
stmt, err := expr.ParseSqlVm(sqlText)
if err != nil {
return nil, err
}
m := &SqlVm{
Statement: stmt,
}
switch v := stmt.(type) {
case *expr.SqlSelect:
m.Keyword = lex.TokenSelect
m.sel = v
case *expr.SqlInsert:
m.Keyword = lex.TokenInsert
m.ins = v
case *expr.SqlDelete:
m.Keyword = lex.TokenDelete
m.del = v
}
return m, nil
}
|
[
"func",
"NewSqlVm",
"(",
"sqlText",
"string",
")",
"(",
"*",
"SqlVm",
",",
"error",
")",
"{",
"stmt",
",",
"err",
":=",
"expr",
".",
"ParseSqlVm",
"(",
"sqlText",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
":=",
"&",
"SqlVm",
"{",
"Statement",
":",
"stmt",
",",
"}",
"\n",
"switch",
"v",
":=",
"stmt",
".",
"(",
"type",
")",
"{",
"case",
"*",
"expr",
".",
"SqlSelect",
":",
"m",
".",
"Keyword",
"=",
"lex",
".",
"TokenSelect",
"\n",
"m",
".",
"sel",
"=",
"v",
"\n",
"case",
"*",
"expr",
".",
"SqlInsert",
":",
"m",
".",
"Keyword",
"=",
"lex",
".",
"TokenInsert",
"\n",
"m",
".",
"ins",
"=",
"v",
"\n",
"case",
"*",
"expr",
".",
"SqlDelete",
":",
"m",
".",
"Keyword",
"=",
"lex",
".",
"TokenDelete",
"\n",
"m",
".",
"del",
"=",
"v",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// SqlVm parsers a sql query into columns, where guards, etc
//
|
[
"SqlVm",
"parsers",
"a",
"sql",
"query",
"into",
"columns",
"where",
"guards",
"etc"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/vm/_archive/vm_sql.go#L30-L51
|
20,682
|
araddon/qlbridge
|
vm/_archive/vm_sql.go
|
Execute
|
func (m *SqlVm) Execute(writeContext datasource.ContextWriter, readContext datasource.ContextReader) (err error) {
switch m.Keyword {
case lex.TokenSelect:
return m.ExecuteSelect(writeContext, readContext)
case lex.TokenInsert:
if rowWriter, ok := writeContext.(datasource.RowWriter); ok {
return m.ExecuteInsert(rowWriter)
} else {
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
}
|
go
|
func (m *SqlVm) Execute(writeContext datasource.ContextWriter, readContext datasource.ContextReader) (err error) {
switch m.Keyword {
case lex.TokenSelect:
return m.ExecuteSelect(writeContext, readContext)
case lex.TokenInsert:
if rowWriter, ok := writeContext.(datasource.RowWriter); ok {
return m.ExecuteInsert(rowWriter)
} else {
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
}
|
[
"func",
"(",
"m",
"*",
"SqlVm",
")",
"Execute",
"(",
"writeContext",
"datasource",
".",
"ContextWriter",
",",
"readContext",
"datasource",
".",
"ContextReader",
")",
"(",
"err",
"error",
")",
"{",
"switch",
"m",
".",
"Keyword",
"{",
"case",
"lex",
".",
"TokenSelect",
":",
"return",
"m",
".",
"ExecuteSelect",
"(",
"writeContext",
",",
"readContext",
")",
"\n",
"case",
"lex",
".",
"TokenInsert",
":",
"if",
"rowWriter",
",",
"ok",
":=",
"writeContext",
".",
"(",
"datasource",
".",
"RowWriter",
")",
";",
"ok",
"{",
"return",
"m",
".",
"ExecuteInsert",
"(",
"rowWriter",
")",
"\n",
"}",
"else",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"writeContext",
")",
"\n",
"}",
"\n",
"case",
"lex",
".",
"TokenDelete",
":",
"return",
"m",
".",
"ExecuteDelete",
"(",
"writeContext",
",",
"readContext",
")",
"\n",
"default",
":",
"u",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"m",
".",
"Keyword",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
".",
"Keyword",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Execute applies a parse expression to the specified context's
//
// writeContext in the case of sql query is similar to a recordset for selects,
// or for delete, insert, update it is like the storage layer
//
|
[
"Execute",
"applies",
"a",
"parse",
"expression",
"to",
"the",
"specified",
"context",
"s",
"writeContext",
"in",
"the",
"case",
"of",
"sql",
"query",
"is",
"similar",
"to",
"a",
"recordset",
"for",
"selects",
"or",
"for",
"delete",
"insert",
"update",
"it",
"is",
"like",
"the",
"storage",
"layer"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/vm/_archive/vm_sql.go#L58-L76
|
20,683
|
araddon/qlbridge
|
vm/_archive/vm_sql.go
|
ExecuteSelect
|
func (m *SqlVm) ExecuteSelect(writeContext datasource.ContextWriter, readContext datasource.ContextReader) (err error) {
//defer errRecover(&err)
s := &State{
ExprVm: m,
ContextReader: readContext,
}
s.rv = reflect.ValueOf(s)
// Check and see if we are where Guarded
if m.sel.Where != nil {
//u.Debugf("Has a Where: %v", m.Request.Where.Root.StringAST())
whereValue, ok := s.Walk(m.sel.Where)
if !ok {
return SqlEvalError
}
switch whereVal := whereValue.(type) {
case value.BoolValue:
if whereVal == value.BoolValueFalse {
u.Debugf("Filtering out")
return nil
}
}
//u.Debugf("Matched where: %v", whereValue)
}
for _, col := range m.sel.Columns {
if col.Guard != nil {
// TODO: evaluate if 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()
return
}
|
go
|
func (m *SqlVm) ExecuteSelect(writeContext datasource.ContextWriter, readContext datasource.ContextReader) (err error) {
//defer errRecover(&err)
s := &State{
ExprVm: m,
ContextReader: readContext,
}
s.rv = reflect.ValueOf(s)
// Check and see if we are where Guarded
if m.sel.Where != nil {
//u.Debugf("Has a Where: %v", m.Request.Where.Root.StringAST())
whereValue, ok := s.Walk(m.sel.Where)
if !ok {
return SqlEvalError
}
switch whereVal := whereValue.(type) {
case value.BoolValue:
if whereVal == value.BoolValueFalse {
u.Debugf("Filtering out")
return nil
}
}
//u.Debugf("Matched where: %v", whereValue)
}
for _, col := range m.sel.Columns {
if col.Guard != nil {
// TODO: evaluate if 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()
return
}
|
[
"func",
"(",
"m",
"*",
"SqlVm",
")",
"ExecuteSelect",
"(",
"writeContext",
"datasource",
".",
"ContextWriter",
",",
"readContext",
"datasource",
".",
"ContextReader",
")",
"(",
"err",
"error",
")",
"{",
"//defer errRecover(&err)",
"s",
":=",
"&",
"State",
"{",
"ExprVm",
":",
"m",
",",
"ContextReader",
":",
"readContext",
",",
"}",
"\n",
"s",
".",
"rv",
"=",
"reflect",
".",
"ValueOf",
"(",
"s",
")",
"\n\n",
"// Check and see if we are where Guarded",
"if",
"m",
".",
"sel",
".",
"Where",
"!=",
"nil",
"{",
"//u.Debugf(\"Has a Where: %v\", m.Request.Where.Root.StringAST())",
"whereValue",
",",
"ok",
":=",
"s",
".",
"Walk",
"(",
"m",
".",
"sel",
".",
"Where",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"SqlEvalError",
"\n",
"}",
"\n",
"switch",
"whereVal",
":=",
"whereValue",
".",
"(",
"type",
")",
"{",
"case",
"value",
".",
"BoolValue",
":",
"if",
"whereVal",
"==",
"value",
".",
"BoolValueFalse",
"{",
"u",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"//u.Debugf(\"Matched where: %v\", whereValue)",
"}",
"\n",
"for",
"_",
",",
"col",
":=",
"range",
"m",
".",
"sel",
".",
"Columns",
"{",
"if",
"col",
".",
"Guard",
"!=",
"nil",
"{",
"// TODO: evaluate if guard",
"}",
"\n",
"if",
"col",
".",
"Star",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"readContext",
".",
"Row",
"(",
")",
"{",
"writeContext",
".",
"Put",
"(",
"&",
"expr",
".",
"Column",
"{",
"As",
":",
"k",
"}",
",",
"nil",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"//u.Debugf(\"tree.Root: as?%v %#v\", col.As, col.Tree.Root)",
"v",
",",
"ok",
":=",
"s",
".",
"Walk",
"(",
"col",
".",
"Tree",
".",
"Root",
")",
"\n",
"if",
"ok",
"{",
"writeContext",
".",
"Put",
"(",
"col",
",",
"readContext",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"//writeContext.Put()",
"return",
"\n",
"}"
] |
// Execute applies a dml sql select expression to the specified context's
//
// writeContext in the case of sql query is similar to a recordset for selects,
// or for delete, insert, update it is like the storage layer
//
|
[
"Execute",
"applies",
"a",
"dml",
"sql",
"select",
"expression",
"to",
"the",
"specified",
"context",
"s",
"writeContext",
"in",
"the",
"case",
"of",
"sql",
"query",
"is",
"similar",
"to",
"a",
"recordset",
"for",
"selects",
"or",
"for",
"delete",
"insert",
"update",
"it",
"is",
"like",
"the",
"storage",
"layer"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/vm/_archive/vm_sql.go#L83-L127
|
20,684
|
araddon/qlbridge
|
exec/order.go
|
NewOrder
|
func NewOrder(ctx *plan.Context, p *plan.Order) *Order {
o := &Order{
TaskBase: NewTaskBase(ctx),
p: p,
complete: make(chan bool),
}
return o
}
|
go
|
func NewOrder(ctx *plan.Context, p *plan.Order) *Order {
o := &Order{
TaskBase: NewTaskBase(ctx),
p: p,
complete: make(chan bool),
}
return o
}
|
[
"func",
"NewOrder",
"(",
"ctx",
"*",
"plan",
".",
"Context",
",",
"p",
"*",
"plan",
".",
"Order",
")",
"*",
"Order",
"{",
"o",
":=",
"&",
"Order",
"{",
"TaskBase",
":",
"NewTaskBase",
"(",
"ctx",
")",
",",
"p",
":",
"p",
",",
"complete",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"}",
"\n",
"return",
"o",
"\n",
"}"
] |
// NewORder create new order by exec task
|
[
"NewORder",
"create",
"new",
"order",
"by",
"exec",
"task"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/exec/order.go#L26-L33
|
20,685
|
araddon/qlbridge
|
dialects/_influxql/dialect.go
|
LexInfluxName
|
func LexInfluxName(l *lex.Lexer) lex.StateFn {
l.SkipWhiteSpaces()
firstChar := l.Peek()
u.Debugf("LexInfluxName: %v", string(firstChar))
switch firstChar {
case '"':
return lex.LexValue(l)
case '/':
// a regex
return lex.LexRegex(l)
}
return lex.LexIdentifier
}
|
go
|
func LexInfluxName(l *lex.Lexer) lex.StateFn {
l.SkipWhiteSpaces()
firstChar := l.Peek()
u.Debugf("LexInfluxName: %v", string(firstChar))
switch firstChar {
case '"':
return lex.LexValue(l)
case '/':
// a regex
return lex.LexRegex(l)
}
return lex.LexIdentifier
}
|
[
"func",
"LexInfluxName",
"(",
"l",
"*",
"lex",
".",
"Lexer",
")",
"lex",
".",
"StateFn",
"{",
"l",
".",
"SkipWhiteSpaces",
"(",
")",
"\n",
"firstChar",
":=",
"l",
".",
"Peek",
"(",
")",
"\n",
"u",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"string",
"(",
"firstChar",
")",
")",
"\n\n",
"switch",
"firstChar",
"{",
"case",
"'\"'",
":",
"return",
"lex",
".",
"LexValue",
"(",
"l",
")",
"\n",
"case",
"'/'",
":",
"// a regex",
"return",
"lex",
".",
"LexRegex",
"(",
"l",
")",
"\n",
"}",
"\n",
"return",
"lex",
".",
"LexIdentifier",
"\n",
"}"
] |
// lex value
//
// SIMPLE_NAME_VALUE | TABLE_NAME_VALUE | REGEX_VALUE
|
[
"lex",
"value",
"SIMPLE_NAME_VALUE",
"|",
"TABLE_NAME_VALUE",
"|",
"REGEX_VALUE"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/dialects/_influxql/dialect.go#L98-L112
|
20,686
|
araddon/qlbridge
|
datasource/files/filestore.go
|
FileStoreLoader
|
func FileStoreLoader(ss *schema.Schema) (cloudstorage.StoreReader, error) {
if ss == nil || ss.Conf == nil {
return nil, fmt.Errorf("No config info for files source for %v", ss)
}
//u.Debugf("json conf:\n%s", ss.Conf.Settings.PrettyJson())
storeType := ss.Conf.Settings.String("type")
if storeType == "" {
return nil, fmt.Errorf("Expected 'type' in File Store definition 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)
}
|
go
|
func FileStoreLoader(ss *schema.Schema) (cloudstorage.StoreReader, error) {
if ss == nil || ss.Conf == nil {
return nil, fmt.Errorf("No config info for files source for %v", ss)
}
//u.Debugf("json conf:\n%s", ss.Conf.Settings.PrettyJson())
storeType := ss.Conf.Settings.String("type")
if storeType == "" {
return nil, fmt.Errorf("Expected 'type' in File Store definition 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)
}
|
[
"func",
"FileStoreLoader",
"(",
"ss",
"*",
"schema",
".",
"Schema",
")",
"(",
"cloudstorage",
".",
"StoreReader",
",",
"error",
")",
"{",
"if",
"ss",
"==",
"nil",
"||",
"ss",
".",
"Conf",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ss",
")",
"\n",
"}",
"\n\n",
"//u.Debugf(\"json conf:\\n%s\", ss.Conf.Settings.PrettyJson())",
"storeType",
":=",
"ss",
".",
"Conf",
".",
"Settings",
".",
"String",
"(",
"\"",
"\"",
")",
"\n",
"if",
"storeType",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"fileStoreMu",
".",
"Lock",
"(",
")",
"\n",
"storeType",
"=",
"strings",
".",
"ToLower",
"(",
"storeType",
")",
"\n",
"fs",
",",
"ok",
":=",
"fileStores",
"[",
"storeType",
"]",
"\n",
"fileStoreMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"storeType",
")",
"\n",
"}",
"\n\n",
"return",
"fs",
"(",
"ss",
")",
"\n",
"}"
] |
// FileStoreLoader defines the interface for loading files
|
[
"FileStoreLoader",
"defines",
"the",
"interface",
"for",
"loading",
"files"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/files/filestore.go#L47-L68
|
20,687
|
araddon/qlbridge
|
datasource/files/filestore.go
|
RegisterFileStore
|
func RegisterFileStore(storeType string, fs FileStoreCreator) {
if fs == nil {
panic("FileStore must not be nil")
}
storeType = strings.ToLower(storeType)
u.Debugf("global FileStore 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
}
|
go
|
func RegisterFileStore(storeType string, fs FileStoreCreator) {
if fs == nil {
panic("FileStore must not be nil")
}
storeType = strings.ToLower(storeType)
u.Debugf("global FileStore 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
}
|
[
"func",
"RegisterFileStore",
"(",
"storeType",
"string",
",",
"fs",
"FileStoreCreator",
")",
"{",
"if",
"fs",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"storeType",
"=",
"strings",
".",
"ToLower",
"(",
"storeType",
")",
"\n",
"u",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"storeType",
",",
"fs",
",",
"fs",
")",
"\n",
"fileStoreMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"fileStoreMu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"_",
",",
"dupe",
":=",
"fileStores",
"[",
"storeType",
"]",
";",
"dupe",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"storeType",
")",
"\n",
"}",
"\n",
"fileStores",
"[",
"storeType",
"]",
"=",
"fs",
"\n",
"}"
] |
// RegisterFileStore global registry for Registering
// implementations of FileStore factories of the provided @storeType
|
[
"RegisterFileStore",
"global",
"registry",
"for",
"Registering",
"implementations",
"of",
"FileStore",
"factories",
"of",
"the",
"provided"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/files/filestore.go#L87-L99
|
20,688
|
araddon/qlbridge
|
datasource/introspect.go
|
IntrospectSchema
|
func IntrospectSchema(s *schema.Schema, name string, iter schema.Iterator) error {
tbl, err := s.Table(name)
if err != nil {
u.Errorf("Could not find table %q", name)
return err
}
return IntrospectTable(tbl, iter)
}
|
go
|
func IntrospectSchema(s *schema.Schema, name string, iter schema.Iterator) error {
tbl, err := s.Table(name)
if err != nil {
u.Errorf("Could not find table %q", name)
return err
}
return IntrospectTable(tbl, iter)
}
|
[
"func",
"IntrospectSchema",
"(",
"s",
"*",
"schema",
".",
"Schema",
",",
"name",
"string",
",",
"iter",
"schema",
".",
"Iterator",
")",
"error",
"{",
"tbl",
",",
"err",
":=",
"s",
".",
"Table",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"IntrospectTable",
"(",
"tbl",
",",
"iter",
")",
"\n",
"}"
] |
// IntrospectSchema discover schema from contents of row introspection.
|
[
"IntrospectSchema",
"discover",
"schema",
"from",
"contents",
"of",
"row",
"introspection",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/introspect.go#L21-L28
|
20,689
|
araddon/qlbridge
|
rel/parse_sql.go
|
ParseSqlSelectResolver
|
func ParseSqlSelectResolver(sqlQuery string, fr expr.FuncResolver) (*SqlSelect, error) {
stmt, err := parseSqlResolver(sqlQuery, fr)
if err != nil {
return nil, err
}
sel, ok := stmt.(*SqlSelect)
if !ok {
return nil, fmt.Errorf("Expected SqlSelect but got %T", stmt)
}
return sel, nil
}
|
go
|
func ParseSqlSelectResolver(sqlQuery string, fr expr.FuncResolver) (*SqlSelect, error) {
stmt, err := parseSqlResolver(sqlQuery, fr)
if err != nil {
return nil, err
}
sel, ok := stmt.(*SqlSelect)
if !ok {
return nil, fmt.Errorf("Expected SqlSelect but got %T", stmt)
}
return sel, nil
}
|
[
"func",
"ParseSqlSelectResolver",
"(",
"sqlQuery",
"string",
",",
"fr",
"expr",
".",
"FuncResolver",
")",
"(",
"*",
"SqlSelect",
",",
"error",
")",
"{",
"stmt",
",",
"err",
":=",
"parseSqlResolver",
"(",
"sqlQuery",
",",
"fr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"sel",
",",
"ok",
":=",
"stmt",
".",
"(",
"*",
"SqlSelect",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"stmt",
")",
"\n",
"}",
"\n",
"return",
"sel",
",",
"nil",
"\n",
"}"
] |
// ParseSqlSelectResolver parse as SELECT using function resolver.
|
[
"ParseSqlSelectResolver",
"parse",
"as",
"SELECT",
"using",
"function",
"resolver",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L56-L66
|
20,690
|
araddon/qlbridge
|
rel/parse_sql.go
|
ParseSqlStatements
|
func ParseSqlStatements(sqlQuery string) ([]SqlStatement, error) {
l := lex.NewSqlLexer(sqlQuery)
m := Sqlbridge{l: l, SqlTokenPager: NewSqlTokenPager(l)}
stmts := make([]SqlStatement, 0)
for {
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
}
|
go
|
func ParseSqlStatements(sqlQuery string) ([]SqlStatement, error) {
l := lex.NewSqlLexer(sqlQuery)
m := Sqlbridge{l: l, SqlTokenPager: NewSqlTokenPager(l)}
stmts := make([]SqlStatement, 0)
for {
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
}
|
[
"func",
"ParseSqlStatements",
"(",
"sqlQuery",
"string",
")",
"(",
"[",
"]",
"SqlStatement",
",",
"error",
")",
"{",
"l",
":=",
"lex",
".",
"NewSqlLexer",
"(",
"sqlQuery",
")",
"\n",
"m",
":=",
"Sqlbridge",
"{",
"l",
":",
"l",
",",
"SqlTokenPager",
":",
"NewSqlTokenPager",
"(",
"l",
")",
"}",
"\n",
"stmts",
":=",
"make",
"(",
"[",
"]",
"SqlStatement",
",",
"0",
")",
"\n",
"for",
"{",
"stmt",
",",
"err",
":=",
"m",
".",
"parse",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"err",
"}",
"\n",
"}",
"\n",
"stmts",
"=",
"append",
"(",
"stmts",
",",
"stmt",
")",
"\n",
"sqlRemaining",
",",
"hasMore",
":=",
"l",
".",
"Remainder",
"(",
")",
"\n",
"if",
"!",
"hasMore",
"{",
"break",
"\n",
"}",
"\n",
"l",
"=",
"lex",
".",
"NewSqlLexer",
"(",
"sqlRemaining",
")",
"\n",
"m",
"=",
"Sqlbridge",
"{",
"l",
":",
"l",
",",
"SqlTokenPager",
":",
"NewSqlTokenPager",
"(",
"l",
")",
"}",
"\n",
"}",
"\n",
"return",
"stmts",
",",
"nil",
"\n",
"}"
] |
// ParseSqlStatements into array of SQL Statements
|
[
"ParseSqlStatements",
"into",
"array",
"of",
"SQL",
"Statements"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L69-L87
|
20,691
|
araddon/qlbridge
|
rel/parse_sql.go
|
parseSqlInsert
|
func (m *Sqlbridge) parseSqlInsert() (*SqlInsert, error) {
// insert into mytable (id, str) values (0, "a")
req := NewSqlInsert()
req.kw = m.Cur().T
m.Next() // Consume Insert or Replace
// INTO
if m.Cur().T != lex.TokenInto {
return nil, fmt.Errorf("expected INTO but got: %v", m.Cur())
}
m.Next() // Consume INTO
// table name
switch m.Cur().T {
case lex.TokenTable:
req.Table = m.Cur().V
m.Next()
default:
return nil, fmt.Errorf("expected table name but got : %v", m.Cur().V)
}
// list of fields
cols, err := m.parseFieldList()
if err != nil {
return nil, err
}
req.Columns = cols
m.Next() // left paren starts lisf of values
switch m.Cur().T {
case lex.TokenValues:
m.Next() // Consume Values keyword
case lex.TokenSelect:
sel, err := m.parseSqlSelect()
if 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 = colVals
return req, nil
}
|
go
|
func (m *Sqlbridge) parseSqlInsert() (*SqlInsert, error) {
// insert into mytable (id, str) values (0, "a")
req := NewSqlInsert()
req.kw = m.Cur().T
m.Next() // Consume Insert or Replace
// INTO
if m.Cur().T != lex.TokenInto {
return nil, fmt.Errorf("expected INTO but got: %v", m.Cur())
}
m.Next() // Consume INTO
// table name
switch m.Cur().T {
case lex.TokenTable:
req.Table = m.Cur().V
m.Next()
default:
return nil, fmt.Errorf("expected table name but got : %v", m.Cur().V)
}
// list of fields
cols, err := m.parseFieldList()
if err != nil {
return nil, err
}
req.Columns = cols
m.Next() // left paren starts lisf of values
switch m.Cur().T {
case lex.TokenValues:
m.Next() // Consume Values keyword
case lex.TokenSelect:
sel, err := m.parseSqlSelect()
if 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 = colVals
return req, nil
}
|
[
"func",
"(",
"m",
"*",
"Sqlbridge",
")",
"parseSqlInsert",
"(",
")",
"(",
"*",
"SqlInsert",
",",
"error",
")",
"{",
"// insert into mytable (id, str) values (0, \"a\")",
"req",
":=",
"NewSqlInsert",
"(",
")",
"\n",
"req",
".",
"kw",
"=",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"\n",
"m",
".",
"Next",
"(",
")",
"// Consume Insert or Replace",
"\n\n",
"// INTO",
"if",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"!=",
"lex",
".",
"TokenInto",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
".",
"Cur",
"(",
")",
")",
"\n",
"}",
"\n",
"m",
".",
"Next",
"(",
")",
"// Consume INTO",
"\n\n",
"// table name",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenTable",
":",
"req",
".",
"Table",
"=",
"m",
".",
"Cur",
"(",
")",
".",
"V",
"\n",
"m",
".",
"Next",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
".",
"Cur",
"(",
")",
".",
"V",
")",
"\n",
"}",
"\n\n",
"// list of fields",
"cols",
",",
"err",
":=",
"m",
".",
"parseFieldList",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Columns",
"=",
"cols",
"\n\n",
"m",
".",
"Next",
"(",
")",
"// left paren starts lisf of values",
"\n",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenValues",
":",
"m",
".",
"Next",
"(",
")",
"// Consume Values keyword",
"\n",
"case",
"lex",
".",
"TokenSelect",
":",
"sel",
",",
"err",
":=",
"m",
".",
"parseSqlSelect",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"sel",
".",
"From",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"req",
".",
"Select",
"=",
"sel",
"\n",
"return",
"req",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"colVals",
",",
"err",
":=",
"m",
".",
"parseValueList",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Rows",
"=",
"colVals",
"\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] |
// First keyword was INSERT, REPLACE
|
[
"First",
"keyword",
"was",
"INSERT",
"REPLACE"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L281-L334
|
20,692
|
araddon/qlbridge
|
rel/parse_sql.go
|
parseSqlUpdate
|
func (m *Sqlbridge) parseSqlUpdate() (*SqlUpdate, error) {
req := NewSqlUpdate()
m.Next() // Consume UPDATE token
//u.Debugf("token: %v", m.Cur())
switch m.Cur().T {
case lex.TokenTable, lex.TokenIdentity:
req.Table = m.Cur().V
default:
return nil, fmt.Errorf("expected table name but got : %v", m.Cur().V)
}
m.Next()
if m.Cur().T != lex.TokenSet {
return nil, fmt.Errorf("expected SET after table name but got : %v", m.Cur().V)
}
// 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
}
|
go
|
func (m *Sqlbridge) parseSqlUpdate() (*SqlUpdate, error) {
req := NewSqlUpdate()
m.Next() // Consume UPDATE token
//u.Debugf("token: %v", m.Cur())
switch m.Cur().T {
case lex.TokenTable, lex.TokenIdentity:
req.Table = m.Cur().V
default:
return nil, fmt.Errorf("expected table name but got : %v", m.Cur().V)
}
m.Next()
if m.Cur().T != lex.TokenSet {
return nil, fmt.Errorf("expected SET after table name but got : %v", m.Cur().V)
}
// 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
}
|
[
"func",
"(",
"m",
"*",
"Sqlbridge",
")",
"parseSqlUpdate",
"(",
")",
"(",
"*",
"SqlUpdate",
",",
"error",
")",
"{",
"req",
":=",
"NewSqlUpdate",
"(",
")",
"\n",
"m",
".",
"Next",
"(",
")",
"// Consume UPDATE token",
"\n\n",
"//u.Debugf(\"token: %v\", m.Cur())",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenTable",
",",
"lex",
".",
"TokenIdentity",
":",
"req",
".",
"Table",
"=",
"m",
".",
"Cur",
"(",
")",
".",
"V",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
".",
"Cur",
"(",
")",
".",
"V",
")",
"\n",
"}",
"\n",
"m",
".",
"Next",
"(",
")",
"\n",
"if",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"!=",
"lex",
".",
"TokenSet",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
".",
"Cur",
"(",
")",
".",
"V",
")",
"\n",
"}",
"\n\n",
"// list of name=value pairs",
"m",
".",
"Next",
"(",
")",
"\n",
"cols",
",",
"err",
":=",
"m",
".",
"parseUpdateList",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Values",
"=",
"cols",
"\n\n",
"// WHERE",
"req",
".",
"Where",
",",
"err",
"=",
"m",
".",
"parseWhere",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] |
// First keyword was UPDATE
|
[
"First",
"keyword",
"was",
"UPDATE"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L337-L370
|
20,693
|
araddon/qlbridge
|
rel/parse_sql.go
|
parseSqlUpsert
|
func (m *Sqlbridge) parseSqlUpsert() (*SqlUpsert, error) {
var err error
req := NewSqlUpsert()
m.Next() // Consume UPSERT token
if m.Cur().T == lex.TokenInto {
m.Next() // consume Into
}
switch m.Cur().T {
case lex.TokenTable, lex.TokenIdentity:
req.Table = m.Cur().V
m.Next()
default:
return nil, fmt.Errorf("expected table name but got : %v", m.Cur().V)
}
switch m.Cur().T {
case lex.TokenSet:
m.Next() // Consume Set
// list of name=value pairs
cols, err := m.parseUpdateList()
if err != nil {
u.Error(err)
return nil, err
}
req.Values = cols
case lex.TokenLeftParenthesis:
// list of fields
cols, err := m.parseFieldList()
if err != nil {
u.Error(err)
return nil, err
}
req.Columns = cols
m.Next() // left paren starts lisf of values
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.ErrMsg("expected SET name=value, or (col1,col2) after table name")
}
// WHERE
req.Where, err = m.parseWhere()
if err != nil {
return nil, err
}
return req, nil
}
|
go
|
func (m *Sqlbridge) parseSqlUpsert() (*SqlUpsert, error) {
var err error
req := NewSqlUpsert()
m.Next() // Consume UPSERT token
if m.Cur().T == lex.TokenInto {
m.Next() // consume Into
}
switch m.Cur().T {
case lex.TokenTable, lex.TokenIdentity:
req.Table = m.Cur().V
m.Next()
default:
return nil, fmt.Errorf("expected table name but got : %v", m.Cur().V)
}
switch m.Cur().T {
case lex.TokenSet:
m.Next() // Consume Set
// list of name=value pairs
cols, err := m.parseUpdateList()
if err != nil {
u.Error(err)
return nil, err
}
req.Values = cols
case lex.TokenLeftParenthesis:
// list of fields
cols, err := m.parseFieldList()
if err != nil {
u.Error(err)
return nil, err
}
req.Columns = cols
m.Next() // left paren starts lisf of values
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.ErrMsg("expected SET name=value, or (col1,col2) after table name")
}
// WHERE
req.Where, err = m.parseWhere()
if err != nil {
return nil, err
}
return req, nil
}
|
[
"func",
"(",
"m",
"*",
"Sqlbridge",
")",
"parseSqlUpsert",
"(",
")",
"(",
"*",
"SqlUpsert",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"req",
":=",
"NewSqlUpsert",
"(",
")",
"\n",
"m",
".",
"Next",
"(",
")",
"// Consume UPSERT token",
"\n\n",
"if",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"==",
"lex",
".",
"TokenInto",
"{",
"m",
".",
"Next",
"(",
")",
"// consume Into",
"\n",
"}",
"\n\n",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenTable",
",",
"lex",
".",
"TokenIdentity",
":",
"req",
".",
"Table",
"=",
"m",
".",
"Cur",
"(",
")",
".",
"V",
"\n",
"m",
".",
"Next",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
".",
"Cur",
"(",
")",
".",
"V",
")",
"\n",
"}",
"\n\n",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenSet",
":",
"m",
".",
"Next",
"(",
")",
"// Consume Set",
"\n",
"// list of name=value pairs",
"cols",
",",
"err",
":=",
"m",
".",
"parseUpdateList",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Values",
"=",
"cols",
"\n",
"case",
"lex",
".",
"TokenLeftParenthesis",
":",
"// list of fields",
"cols",
",",
"err",
":=",
"m",
".",
"parseFieldList",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Columns",
"=",
"cols",
"\n\n",
"m",
".",
"Next",
"(",
")",
"// left paren starts lisf of values",
"\n",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenValues",
":",
"m",
".",
"Next",
"(",
")",
"// Consume Values keyword",
"\n",
"default",
":",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"//u.Debugf(\"found ? %v\", m.Cur())",
"colVals",
",",
"err",
":=",
"m",
".",
"parseValueList",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"u",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Rows",
"=",
"colVals",
"\n",
"default",
":",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// WHERE",
"req",
".",
"Where",
",",
"err",
"=",
"m",
".",
"parseWhere",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] |
// First keyword was UPSERT
|
[
"First",
"keyword",
"was",
"UPSERT"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L373-L437
|
20,694
|
araddon/qlbridge
|
rel/parse_sql.go
|
parseSqlDelete
|
func (m *Sqlbridge) parseSqlDelete() (*SqlDelete, error) {
req := NewSqlDelete()
m.Next() // Consume Delete
// from
//u.Debugf("token: %v", m.Cur())
if m.Cur().T != lex.TokenFrom {
return nil, m.ErrMsg("expected FROM")
} else {
// table name
m.Next()
//u.Debugf("found table? %v", m.Cur())
switch m.Cur().T {
case lex.TokenTable:
req.Table = m.Cur().V
default:
return nil, m.ErrMsg("expected table 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
}
|
go
|
func (m *Sqlbridge) parseSqlDelete() (*SqlDelete, error) {
req := NewSqlDelete()
m.Next() // Consume Delete
// from
//u.Debugf("token: %v", m.Cur())
if m.Cur().T != lex.TokenFrom {
return nil, m.ErrMsg("expected FROM")
} else {
// table name
m.Next()
//u.Debugf("found table? %v", m.Cur())
switch m.Cur().T {
case lex.TokenTable:
req.Table = m.Cur().V
default:
return nil, m.ErrMsg("expected table 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
}
|
[
"func",
"(",
"m",
"*",
"Sqlbridge",
")",
"parseSqlDelete",
"(",
")",
"(",
"*",
"SqlDelete",
",",
"error",
")",
"{",
"req",
":=",
"NewSqlDelete",
"(",
")",
"\n",
"m",
".",
"Next",
"(",
")",
"// Consume Delete",
"\n\n",
"// from",
"//u.Debugf(\"token: %v\", m.Cur())",
"if",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"!=",
"lex",
".",
"TokenFrom",
"{",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"// table name",
"m",
".",
"Next",
"(",
")",
"\n",
"//u.Debugf(\"found table? %v\", m.Cur())",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenTable",
":",
"req",
".",
"Table",
"=",
"m",
".",
"Cur",
"(",
")",
".",
"V",
"\n",
"default",
":",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"m",
".",
"Next",
"(",
")",
"\n",
"//u.Debugf(\"cur lex.Token: %s\", m.Cur().T.String())",
"if",
"errreq",
":=",
"m",
".",
"parseWhereDelete",
"(",
"req",
")",
";",
"errreq",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errreq",
"\n",
"}",
"\n",
"// we are good",
"return",
"req",
",",
"nil",
"\n",
"}"
] |
// First keyword was DELETE
|
[
"First",
"keyword",
"was",
"DELETE"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L440-L468
|
20,695
|
araddon/qlbridge
|
rel/parse_sql.go
|
parsePrepare
|
func (m *Sqlbridge) parsePrepare() (*PreparedStatement, error) {
req := NewPreparedStatement()
m.Next() // Consume Prepare
// statement name/alias
//u.Debugf("found table? %v", m.Cur())
switch m.Cur().T {
case lex.TokenTable, lex.TokenIdentity:
req.Alias = m.Cur().V
default:
return nil, m.ErrMsg("expected statement name")
}
// from
m.Next()
//u.Debugf("token: %v", m.Cur())
if m.Cur().T != lex.TokenFrom {
return nil, m.ErrMsg("expected FROM")
}
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
}
|
go
|
func (m *Sqlbridge) parsePrepare() (*PreparedStatement, error) {
req := NewPreparedStatement()
m.Next() // Consume Prepare
// statement name/alias
//u.Debugf("found table? %v", m.Cur())
switch m.Cur().T {
case lex.TokenTable, lex.TokenIdentity:
req.Alias = m.Cur().V
default:
return nil, m.ErrMsg("expected statement name")
}
// from
m.Next()
//u.Debugf("token: %v", m.Cur())
if m.Cur().T != lex.TokenFrom {
return nil, m.ErrMsg("expected FROM")
}
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
}
|
[
"func",
"(",
"m",
"*",
"Sqlbridge",
")",
"parsePrepare",
"(",
")",
"(",
"*",
"PreparedStatement",
",",
"error",
")",
"{",
"req",
":=",
"NewPreparedStatement",
"(",
")",
"\n",
"m",
".",
"Next",
"(",
")",
"// Consume Prepare",
"\n\n",
"// statement name/alias",
"//u.Debugf(\"found table? %v\", m.Cur())",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenTable",
",",
"lex",
".",
"TokenIdentity",
":",
"req",
".",
"Alias",
"=",
"m",
".",
"Cur",
"(",
")",
".",
"V",
"\n",
"default",
":",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// from",
"m",
".",
"Next",
"(",
")",
"\n",
"//u.Debugf(\"token: %v\", m.Cur())",
"if",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"!=",
"lex",
".",
"TokenFrom",
"{",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
".",
"Next",
"(",
")",
"\n",
"if",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"!=",
"lex",
".",
"TokenValue",
"{",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"stmt",
",",
"err",
":=",
"ParseSql",
"(",
"m",
".",
"Cur",
"(",
")",
".",
"V",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Statement",
"=",
"stmt",
"\n",
"// we are good",
"return",
"req",
",",
"nil",
"\n",
"}"
] |
// First keyword was PREPARE
|
[
"First",
"keyword",
"was",
"PREPARE"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L471-L503
|
20,696
|
araddon/qlbridge
|
rel/parse_sql.go
|
parseDescribe
|
func (m *Sqlbridge) parseDescribe() (SqlStatement, error) {
req := &SqlDescribe{Raw: m.l.RawInput()}
req.Tok = m.Cur()
m.Next() // Consume Describe
//u.Debugf("token: %v", m.Cur())
switch nextWord := strings.ToLower(m.Cur().V); nextWord {
case "select":
// TODO: make the lexer handle this
sqlText := strings.Replace(m.l.RawInput(), req.Tok.V, "", 1)
sqlSel, err := ParseSql(sqlText)
if err != nil {
return nil, err
}
req.Stmt = sqlSel
return req, nil
case "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
} else {
return nil, m.ErrMsg("expected idenity")
}
}
return req, nil
}
|
go
|
func (m *Sqlbridge) parseDescribe() (SqlStatement, error) {
req := &SqlDescribe{Raw: m.l.RawInput()}
req.Tok = m.Cur()
m.Next() // Consume Describe
//u.Debugf("token: %v", m.Cur())
switch nextWord := strings.ToLower(m.Cur().V); nextWord {
case "select":
// TODO: make the lexer handle this
sqlText := strings.Replace(m.l.RawInput(), req.Tok.V, "", 1)
sqlSel, err := ParseSql(sqlText)
if err != nil {
return nil, err
}
req.Stmt = sqlSel
return req, nil
case "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
} else {
return nil, m.ErrMsg("expected idenity")
}
}
return req, nil
}
|
[
"func",
"(",
"m",
"*",
"Sqlbridge",
")",
"parseDescribe",
"(",
")",
"(",
"SqlStatement",
",",
"error",
")",
"{",
"req",
":=",
"&",
"SqlDescribe",
"{",
"Raw",
":",
"m",
".",
"l",
".",
"RawInput",
"(",
")",
"}",
"\n",
"req",
".",
"Tok",
"=",
"m",
".",
"Cur",
"(",
")",
"\n",
"m",
".",
"Next",
"(",
")",
"// Consume Describe",
"\n\n",
"//u.Debugf(\"token: %v\", m.Cur())",
"switch",
"nextWord",
":=",
"strings",
".",
"ToLower",
"(",
"m",
".",
"Cur",
"(",
")",
".",
"V",
")",
";",
"nextWord",
"{",
"case",
"\"",
"\"",
":",
"// TODO: make the lexer handle this",
"sqlText",
":=",
"strings",
".",
"Replace",
"(",
"m",
".",
"l",
".",
"RawInput",
"(",
")",
",",
"req",
".",
"Tok",
".",
"V",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"sqlSel",
",",
"err",
":=",
"ParseSql",
"(",
"sqlText",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Stmt",
"=",
"sqlSel",
"\n",
"return",
"req",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"sqlText",
":=",
"strings",
".",
"Replace",
"(",
"m",
".",
"l",
".",
"RawInput",
"(",
")",
",",
"req",
".",
"Tok",
".",
"V",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"sqlText",
"=",
"strings",
".",
"Replace",
"(",
"sqlText",
",",
"m",
".",
"Cur",
"(",
")",
".",
"V",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"sqlSel",
",",
"err",
":=",
"ParseSql",
"(",
"sqlText",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Stmt",
"=",
"sqlSel",
"\n",
"return",
"req",
",",
"nil",
"\n",
"default",
":",
"if",
"lex",
".",
"TokenIdentity",
"==",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"req",
".",
"Identity",
"=",
"m",
".",
"Cur",
"(",
")",
".",
"V",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] |
// First keyword was DESCRIBE
|
[
"First",
"keyword",
"was",
"DESCRIBE"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L506-L542
|
20,697
|
araddon/qlbridge
|
rel/parse_sql.go
|
parseCommand
|
func (m *Sqlbridge) parseCommand() (*SqlCommand, error) {
/*
- SET CHARACTER SET utf8
- SET NAMES utf8
*/
req := &SqlCommand{Columns: make(CommandColumns, 0)}
req.kw = m.Next().T // USE, SET
// USE `baseball`;
if req.kw == lex.TokenUse {
req.Identity = m.Next().V
return req, nil
}
cur := m.Cur()
peek := m.Peek()
// Look for special cases for mysql weird SET syntax
switch {
case cur.T == lex.TokenIdentity && strings.ToLower(cur.V) == "names":
//SET NAMES utf8
m.Next() // consume NAMES
col := &CommandColumn{Name: fmt.Sprintf("%s %s", cur.V, m.Next().V)}
req.Columns = append(req.Columns, col)
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
}
return req, m.parseCommandColumns(req)
}
|
go
|
func (m *Sqlbridge) parseCommand() (*SqlCommand, error) {
/*
- SET CHARACTER SET utf8
- SET NAMES utf8
*/
req := &SqlCommand{Columns: make(CommandColumns, 0)}
req.kw = m.Next().T // USE, SET
// USE `baseball`;
if req.kw == lex.TokenUse {
req.Identity = m.Next().V
return req, nil
}
cur := m.Cur()
peek := m.Peek()
// Look for special cases for mysql weird SET syntax
switch {
case cur.T == lex.TokenIdentity && strings.ToLower(cur.V) == "names":
//SET NAMES utf8
m.Next() // consume NAMES
col := &CommandColumn{Name: fmt.Sprintf("%s %s", cur.V, m.Next().V)}
req.Columns = append(req.Columns, col)
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
}
return req, m.parseCommandColumns(req)
}
|
[
"func",
"(",
"m",
"*",
"Sqlbridge",
")",
"parseCommand",
"(",
")",
"(",
"*",
"SqlCommand",
",",
"error",
")",
"{",
"/*\n\t\t- SET CHARACTER SET utf8\n\t\t- SET NAMES utf8\n\t*/",
"req",
":=",
"&",
"SqlCommand",
"{",
"Columns",
":",
"make",
"(",
"CommandColumns",
",",
"0",
")",
"}",
"\n",
"req",
".",
"kw",
"=",
"m",
".",
"Next",
"(",
")",
".",
"T",
"// USE, SET",
"\n\n",
"// USE `baseball`;",
"if",
"req",
".",
"kw",
"==",
"lex",
".",
"TokenUse",
"{",
"req",
".",
"Identity",
"=",
"m",
".",
"Next",
"(",
")",
".",
"V",
"\n",
"return",
"req",
",",
"nil",
"\n",
"}",
"\n\n",
"cur",
":=",
"m",
".",
"Cur",
"(",
")",
"\n",
"peek",
":=",
"m",
".",
"Peek",
"(",
")",
"\n",
"// Look for special cases for mysql weird SET syntax",
"switch",
"{",
"case",
"cur",
".",
"T",
"==",
"lex",
".",
"TokenIdentity",
"&&",
"strings",
".",
"ToLower",
"(",
"cur",
".",
"V",
")",
"==",
"\"",
"\"",
":",
"//SET NAMES utf8",
"m",
".",
"Next",
"(",
")",
"// consume NAMES",
"\n",
"col",
":=",
"&",
"CommandColumn",
"{",
"Name",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cur",
".",
"V",
",",
"m",
".",
"Next",
"(",
")",
".",
"V",
")",
"}",
"\n",
"req",
".",
"Columns",
"=",
"append",
"(",
"req",
".",
"Columns",
",",
"col",
")",
"\n",
"return",
"req",
",",
"nil",
"\n",
"case",
"cur",
".",
"T",
"==",
"lex",
".",
"TokenIdentity",
"&&",
"strings",
".",
"ToLower",
"(",
"cur",
".",
"V",
")",
"==",
"\"",
"\"",
"&&",
"strings",
".",
"ToLower",
"(",
"peek",
".",
"V",
")",
"==",
"\"",
"\"",
":",
"m",
".",
"Next",
"(",
")",
"// consume character",
"\n",
"m",
".",
"Next",
"(",
")",
"// consume set",
"\n",
"col",
":=",
"&",
"CommandColumn",
"{",
"Name",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"Next",
"(",
")",
".",
"V",
")",
"}",
"\n",
"req",
".",
"Columns",
"=",
"append",
"(",
"req",
".",
"Columns",
",",
"col",
")",
"\n",
"return",
"req",
",",
"nil",
"\n",
"}",
"\n",
"return",
"req",
",",
"m",
".",
"parseCommandColumns",
"(",
"req",
")",
"\n",
"}"
] |
// First keyword was SET, USE
|
[
"First",
"keyword",
"was",
"SET",
"USE"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L670-L703
|
20,698
|
araddon/qlbridge
|
rel/parse_sql.go
|
parseDrop
|
func (m *Sqlbridge) parseDrop() (*SqlDrop, error) {
req := NewSqlDrop()
m.Next() // Consume DROP token
req.Raw = m.l.RawInput()
// DROP TEMPORARY TABLE x
if m.Cur().T == lex.TokenTemp {
m.Next()
req.Temp = true
}
// DROP (TABLE|VIEW|SOURCE|CONTINUOUSVIEW) <identity>
switch m.Cur().T {
case lex.TokenTable, lex.TokenView, lex.TokenSource, lex.TokenContinuousView,
lex.TokenSchema, lex.TokenDatabase:
req.Tok = m.Next()
case lex.TokenIdentity:
// triggers, indexes
req.Tok = m.Next()
default:
return nil, m.ErrMsg("Expected view, database,schema, table, source, continuousview for DROP got")
}
switch m.Cur().T {
case lex.TokenTable, lex.TokenIdentity:
req.Identity = 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, etc
}
// WITH
discardComments(m)
with, err := ParseWith(m.SqlTokenPager)
if err != nil {
return nil, err
}
req.With = with
return req, nil
}
|
go
|
func (m *Sqlbridge) parseDrop() (*SqlDrop, error) {
req := NewSqlDrop()
m.Next() // Consume DROP token
req.Raw = m.l.RawInput()
// DROP TEMPORARY TABLE x
if m.Cur().T == lex.TokenTemp {
m.Next()
req.Temp = true
}
// DROP (TABLE|VIEW|SOURCE|CONTINUOUSVIEW) <identity>
switch m.Cur().T {
case lex.TokenTable, lex.TokenView, lex.TokenSource, lex.TokenContinuousView,
lex.TokenSchema, lex.TokenDatabase:
req.Tok = m.Next()
case lex.TokenIdentity:
// triggers, indexes
req.Tok = m.Next()
default:
return nil, m.ErrMsg("Expected view, database,schema, table, source, continuousview for DROP got")
}
switch m.Cur().T {
case lex.TokenTable, lex.TokenIdentity:
req.Identity = 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, etc
}
// WITH
discardComments(m)
with, err := ParseWith(m.SqlTokenPager)
if err != nil {
return nil, err
}
req.With = with
return req, nil
}
|
[
"func",
"(",
"m",
"*",
"Sqlbridge",
")",
"parseDrop",
"(",
")",
"(",
"*",
"SqlDrop",
",",
"error",
")",
"{",
"req",
":=",
"NewSqlDrop",
"(",
")",
"\n",
"m",
".",
"Next",
"(",
")",
"// Consume DROP token",
"\n",
"req",
".",
"Raw",
"=",
"m",
".",
"l",
".",
"RawInput",
"(",
")",
"\n\n",
"// DROP TEMPORARY TABLE x",
"if",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"==",
"lex",
".",
"TokenTemp",
"{",
"m",
".",
"Next",
"(",
")",
"\n",
"req",
".",
"Temp",
"=",
"true",
"\n",
"}",
"\n\n",
"// DROP (TABLE|VIEW|SOURCE|CONTINUOUSVIEW) <identity>",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenTable",
",",
"lex",
".",
"TokenView",
",",
"lex",
".",
"TokenSource",
",",
"lex",
".",
"TokenContinuousView",
",",
"lex",
".",
"TokenSchema",
",",
"lex",
".",
"TokenDatabase",
":",
"req",
".",
"Tok",
"=",
"m",
".",
"Next",
"(",
")",
"\n",
"case",
"lex",
".",
"TokenIdentity",
":",
"// triggers, indexes",
"req",
".",
"Tok",
"=",
"m",
".",
"Next",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"switch",
"m",
".",
"Cur",
"(",
")",
".",
"T",
"{",
"case",
"lex",
".",
"TokenTable",
",",
"lex",
".",
"TokenIdentity",
":",
"req",
".",
"Identity",
"=",
"m",
".",
"Next",
"(",
")",
".",
"V",
"\n",
"default",
":",
"return",
"nil",
",",
"m",
".",
"ErrMsg",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"switch",
"req",
".",
"Tok",
".",
"T",
"{",
"case",
"lex",
".",
"TokenTable",
":",
"// just table",
"case",
"lex",
".",
"TokenSource",
",",
"lex",
".",
"TokenSchema",
":",
"// schema",
"case",
"lex",
".",
"TokenContinuousView",
",",
"lex",
".",
"TokenView",
":",
"// view",
"default",
":",
"// triggers, index, etc",
"}",
"\n\n",
"// WITH",
"discardComments",
"(",
"m",
")",
"\n",
"with",
",",
"err",
":=",
"ParseWith",
"(",
"m",
".",
"SqlTokenPager",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"With",
"=",
"with",
"\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] |
// First keyword was DROP
|
[
"First",
"keyword",
"was",
"DROP"
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/rel/parse_sql.go#L815-L865
|
20,699
|
araddon/qlbridge
|
datasource/context.go
|
MessageConversion
|
func MessageConversion(vals []interface{}) []schema.Message {
msgs := make([]schema.Message, len(vals))
for i, v := range vals {
msgs[i] = v.(schema.Message)
}
return msgs
}
|
go
|
func MessageConversion(vals []interface{}) []schema.Message {
msgs := make([]schema.Message, len(vals))
for i, v := range vals {
msgs[i] = v.(schema.Message)
}
return msgs
}
|
[
"func",
"MessageConversion",
"(",
"vals",
"[",
"]",
"interface",
"{",
"}",
")",
"[",
"]",
"schema",
".",
"Message",
"{",
"msgs",
":=",
"make",
"(",
"[",
"]",
"schema",
".",
"Message",
",",
"len",
"(",
"vals",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"vals",
"{",
"msgs",
"[",
"i",
"]",
"=",
"v",
".",
"(",
"schema",
".",
"Message",
")",
"\n",
"}",
"\n",
"return",
"msgs",
"\n",
"}"
] |
// MessageConversion convert values of type schema.Message.
|
[
"MessageConversion",
"convert",
"values",
"of",
"type",
"schema",
".",
"Message",
"."
] |
23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac
|
https://github.com/araddon/qlbridge/blob/23bb6a4e8c9e82ba86952b8a1469ccff1bb296ac/datasource/context.go#L30-L36
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.