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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
11,000 | influxdata/influxql | ast.go | String | func (s *DeleteStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("DELETE FROM ")
_, _ = buf.WriteString(s.Source.String())
if s.Condition != nil {
_, _ = buf.WriteString(" WHERE ")
_, _ = buf.WriteString(s.Condition.String())
}
return buf.String()
} | go | func (s *DeleteStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("DELETE FROM ")
_, _ = buf.WriteString(s.Source.String())
if s.Condition != nil {
_, _ = buf.WriteString(" WHERE ")
_, _ = buf.WriteString(s.Condition.String())
}
return buf.String()
} | [
"func",
"(",
"s",
"*",
"DeleteStatement",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"s",
".",
"Source",
".",
"String",
"(",
")",
")",
"\n",
"if",
"s",
".",
"Condition",
"!=",
"nil",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"s",
".",
"Condition",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // String returns a string representation of the delete statement. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"delete",
"statement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2105-L2114 |
11,001 | influxdata/influxql | ast.go | RequiredPrivileges | func (s *DeleteStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
return ExecutionPrivileges{{Admin: false, Name: "", Privilege: WritePrivilege}}, nil
} | go | func (s *DeleteStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
return ExecutionPrivileges{{Admin: false, Name: "", Privilege: WritePrivilege}}, nil
} | [
"func",
"(",
"s",
"*",
"DeleteStatement",
")",
"RequiredPrivileges",
"(",
")",
"(",
"ExecutionPrivileges",
",",
"error",
")",
"{",
"return",
"ExecutionPrivileges",
"{",
"{",
"Admin",
":",
"false",
",",
"Name",
":",
"\"",
"\"",
",",
"Privilege",
":",
"WritePrivilege",
"}",
"}",
",",
"nil",
"\n",
"}"
] | // RequiredPrivileges returns the privilege required to execute a DeleteStatement. | [
"RequiredPrivileges",
"returns",
"the",
"privilege",
"required",
"to",
"execute",
"a",
"DeleteStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2117-L2119 |
11,002 | influxdata/influxql | ast.go | DefaultDatabase | func (s *DeleteStatement) DefaultDatabase() string {
if m, ok := s.Source.(*Measurement); ok {
return m.Database
}
return ""
} | go | func (s *DeleteStatement) DefaultDatabase() string {
if m, ok := s.Source.(*Measurement); ok {
return m.Database
}
return ""
} | [
"func",
"(",
"s",
"*",
"DeleteStatement",
")",
"DefaultDatabase",
"(",
")",
"string",
"{",
"if",
"m",
",",
"ok",
":=",
"s",
".",
"Source",
".",
"(",
"*",
"Measurement",
")",
";",
"ok",
"{",
"return",
"m",
".",
"Database",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // DefaultDatabase returns the default database from the statement. | [
"DefaultDatabase",
"returns",
"the",
"default",
"database",
"from",
"the",
"statement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2122-L2127 |
11,003 | influxdata/influxql | ast.go | RequiredPrivileges | func (s *DropShardStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
return ExecutionPrivileges{{Admin: true, Name: "", Privilege: AllPrivileges}}, nil
} | go | func (s *DropShardStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
return ExecutionPrivileges{{Admin: true, Name: "", Privilege: AllPrivileges}}, nil
} | [
"func",
"(",
"s",
"*",
"DropShardStatement",
")",
"RequiredPrivileges",
"(",
")",
"(",
"ExecutionPrivileges",
",",
"error",
")",
"{",
"return",
"ExecutionPrivileges",
"{",
"{",
"Admin",
":",
"true",
",",
"Name",
":",
"\"",
"\"",
",",
"Privilege",
":",
"AllPrivileges",
"}",
"}",
",",
"nil",
"\n",
"}"
] | // RequiredPrivileges returns the privilege required to execute a
// DropShardStatement. | [
"RequiredPrivileges",
"returns",
"the",
"privilege",
"required",
"to",
"execute",
"a",
"DropShardStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2274-L2276 |
11,004 | influxdata/influxql | ast.go | RequiredPrivileges | func (s *ShowContinuousQueriesStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
return ExecutionPrivileges{{Admin: false, Name: "", Privilege: ReadPrivilege}}, nil
} | go | func (s *ShowContinuousQueriesStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
return ExecutionPrivileges{{Admin: false, Name: "", Privilege: ReadPrivilege}}, nil
} | [
"func",
"(",
"s",
"*",
"ShowContinuousQueriesStatement",
")",
"RequiredPrivileges",
"(",
")",
"(",
"ExecutionPrivileges",
",",
"error",
")",
"{",
"return",
"ExecutionPrivileges",
"{",
"{",
"Admin",
":",
"false",
",",
"Name",
":",
"\"",
"\"",
",",
"Privilege",
":",
"ReadPrivilege",
"}",
"}",
",",
"nil",
"\n",
"}"
] | // RequiredPrivileges returns the privilege required to execute a ShowContinuousQueriesStatement. | [
"RequiredPrivileges",
"returns",
"the",
"privilege",
"required",
"to",
"execute",
"a",
"ShowContinuousQueriesStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2356-L2358 |
11,005 | influxdata/influxql | ast.go | String | func (s *ShowGrantsForUserStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("SHOW GRANTS FOR ")
_, _ = buf.WriteString(QuoteIdent(s.Name))
return buf.String()
} | go | func (s *ShowGrantsForUserStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("SHOW GRANTS FOR ")
_, _ = buf.WriteString(QuoteIdent(s.Name))
return buf.String()
} | [
"func",
"(",
"s",
"*",
"ShowGrantsForUserStatement",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"s",
".",
"Name",
")",
")",
"\n\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // String returns a string representation of the show grants for user. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"show",
"grants",
"for",
"user",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2367-L2373 |
11,006 | influxdata/influxql | ast.go | RequiredPrivileges | func (s *ShowDatabasesStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
// SHOW DATABASES is one of few statements that have no required privileges.
// Anyone is allowed to execute it, but the returned results depend on the user's
// individual database permissions.
return ExecutionPrivileges{{Admin: false, Name: "", Privilege: NoPrivileges}}, nil
} | go | func (s *ShowDatabasesStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
// SHOW DATABASES is one of few statements that have no required privileges.
// Anyone is allowed to execute it, but the returned results depend on the user's
// individual database permissions.
return ExecutionPrivileges{{Admin: false, Name: "", Privilege: NoPrivileges}}, nil
} | [
"func",
"(",
"s",
"*",
"ShowDatabasesStatement",
")",
"RequiredPrivileges",
"(",
")",
"(",
"ExecutionPrivileges",
",",
"error",
")",
"{",
"// SHOW DATABASES is one of few statements that have no required privileges.",
"// Anyone is allowed to execute it, but the returned results depend on the user's",
"// individual database permissions.",
"return",
"ExecutionPrivileges",
"{",
"{",
"Admin",
":",
"false",
",",
"Name",
":",
"\"",
"\"",
",",
"Privilege",
":",
"NoPrivileges",
"}",
"}",
",",
"nil",
"\n",
"}"
] | // RequiredPrivileges returns the privilege required to execute a ShowDatabasesStatement. | [
"RequiredPrivileges",
"returns",
"the",
"privilege",
"required",
"to",
"execute",
"a",
"ShowDatabasesStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2387-L2392 |
11,007 | influxdata/influxql | ast.go | RequiredPrivileges | func (s *CreateContinuousQueryStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
ep := ExecutionPrivileges{{Admin: false, Name: s.Database, Privilege: ReadPrivilege}}
// Selecting into a database that's different from the source?
if s.Source.Target.Measurement.Database != "" {
// Change source database privilege requirement to read.
ep[0].Privilege = ReadPrivilege
// Add destination database privilege requirement and set it to write.
p := ExecutionPrivilege{
Admin: false,
Name: s.Source.Target.Measurement.Database,
Privilege: WritePrivilege,
}
ep = append(ep, p)
}
return ep, nil
} | go | func (s *CreateContinuousQueryStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
ep := ExecutionPrivileges{{Admin: false, Name: s.Database, Privilege: ReadPrivilege}}
// Selecting into a database that's different from the source?
if s.Source.Target.Measurement.Database != "" {
// Change source database privilege requirement to read.
ep[0].Privilege = ReadPrivilege
// Add destination database privilege requirement and set it to write.
p := ExecutionPrivilege{
Admin: false,
Name: s.Source.Target.Measurement.Database,
Privilege: WritePrivilege,
}
ep = append(ep, p)
}
return ep, nil
} | [
"func",
"(",
"s",
"*",
"CreateContinuousQueryStatement",
")",
"RequiredPrivileges",
"(",
")",
"(",
"ExecutionPrivileges",
",",
"error",
")",
"{",
"ep",
":=",
"ExecutionPrivileges",
"{",
"{",
"Admin",
":",
"false",
",",
"Name",
":",
"s",
".",
"Database",
",",
"Privilege",
":",
"ReadPrivilege",
"}",
"}",
"\n\n",
"// Selecting into a database that's different from the source?",
"if",
"s",
".",
"Source",
".",
"Target",
".",
"Measurement",
".",
"Database",
"!=",
"\"",
"\"",
"{",
"// Change source database privilege requirement to read.",
"ep",
"[",
"0",
"]",
".",
"Privilege",
"=",
"ReadPrivilege",
"\n\n",
"// Add destination database privilege requirement and set it to write.",
"p",
":=",
"ExecutionPrivilege",
"{",
"Admin",
":",
"false",
",",
"Name",
":",
"s",
".",
"Source",
".",
"Target",
".",
"Measurement",
".",
"Database",
",",
"Privilege",
":",
"WritePrivilege",
",",
"}",
"\n",
"ep",
"=",
"append",
"(",
"ep",
",",
"p",
")",
"\n",
"}",
"\n\n",
"return",
"ep",
",",
"nil",
"\n",
"}"
] | // RequiredPrivileges returns the privilege required to execute a CreateContinuousQueryStatement. | [
"RequiredPrivileges",
"returns",
"the",
"privilege",
"required",
"to",
"execute",
"a",
"CreateContinuousQueryStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2436-L2454 |
11,008 | influxdata/influxql | ast.go | RequiredPrivileges | func (s *ShowMeasurementCardinalityStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
if !s.Exact {
return ExecutionPrivileges{{Admin: false, Name: s.Database, Privilege: ReadPrivilege}}, nil
}
return s.Sources.RequiredPrivileges()
} | go | func (s *ShowMeasurementCardinalityStatement) RequiredPrivileges() (ExecutionPrivileges, error) {
if !s.Exact {
return ExecutionPrivileges{{Admin: false, Name: s.Database, Privilege: ReadPrivilege}}, nil
}
return s.Sources.RequiredPrivileges()
} | [
"func",
"(",
"s",
"*",
"ShowMeasurementCardinalityStatement",
")",
"RequiredPrivileges",
"(",
")",
"(",
"ExecutionPrivileges",
",",
"error",
")",
"{",
"if",
"!",
"s",
".",
"Exact",
"{",
"return",
"ExecutionPrivileges",
"{",
"{",
"Admin",
":",
"false",
",",
"Name",
":",
"s",
".",
"Database",
",",
"Privilege",
":",
"ReadPrivilege",
"}",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"s",
".",
"Sources",
".",
"RequiredPrivileges",
"(",
")",
"\n",
"}"
] | // RequiredPrivileges returns the privilege required to execute a ShowMeasurementCardinalityStatement. | [
"RequiredPrivileges",
"returns",
"the",
"privilege",
"required",
"to",
"execute",
"a",
"ShowMeasurementCardinalityStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2542-L2547 |
11,009 | influxdata/influxql | ast.go | String | func (s *ShowRetentionPoliciesStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("SHOW RETENTION POLICIES")
if s.Database != "" {
_, _ = buf.WriteString(" ON ")
_, _ = buf.WriteString(QuoteIdent(s.Database))
}
return buf.String()
} | go | func (s *ShowRetentionPoliciesStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("SHOW RETENTION POLICIES")
if s.Database != "" {
_, _ = buf.WriteString(" ON ")
_, _ = buf.WriteString(QuoteIdent(s.Database))
}
return buf.String()
} | [
"func",
"(",
"s",
"*",
"ShowRetentionPoliciesStatement",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"if",
"s",
".",
"Database",
"!=",
"\"",
"\"",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"s",
".",
"Database",
")",
")",
"\n",
"}",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // String returns a string representation of a ShowRetentionPoliciesStatement. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"a",
"ShowRetentionPoliciesStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2662-L2670 |
11,010 | influxdata/influxql | ast.go | String | func (s *ShowDiagnosticsStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("SHOW DIAGNOSTICS")
if s.Module != "" {
_, _ = buf.WriteString(" FOR ")
_, _ = buf.WriteString(QuoteString(s.Module))
}
return buf.String()
} | go | func (s *ShowDiagnosticsStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("SHOW DIAGNOSTICS")
if s.Module != "" {
_, _ = buf.WriteString(" FOR ")
_, _ = buf.WriteString(QuoteString(s.Module))
}
return buf.String()
} | [
"func",
"(",
"s",
"*",
"ShowDiagnosticsStatement",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"if",
"s",
".",
"Module",
"!=",
"\"",
"\"",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteString",
"(",
"s",
".",
"Module",
")",
")",
"\n",
"}",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // String returns a string representation of the ShowDiagnosticsStatement. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"ShowDiagnosticsStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2732-L2740 |
11,011 | influxdata/influxql | ast.go | String | func (s *CreateSubscriptionStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("CREATE SUBSCRIPTION ")
_, _ = buf.WriteString(QuoteIdent(s.Name))
_, _ = buf.WriteString(" ON ")
_, _ = buf.WriteString(QuoteIdent(s.Database))
_, _ = buf.WriteString(".")
_, _ = buf.WriteString(QuoteIdent(s.RetentionPolicy))
_, _ = buf.WriteString(" DESTINATIONS ")
_, _ = buf.WriteString(s.Mode)
_, _ = buf.WriteString(" ")
for i, dest := range s.Destinations {
if i != 0 {
_, _ = buf.WriteString(", ")
}
_, _ = buf.WriteString(QuoteString(dest))
}
return buf.String()
} | go | func (s *CreateSubscriptionStatement) String() string {
var buf bytes.Buffer
_, _ = buf.WriteString("CREATE SUBSCRIPTION ")
_, _ = buf.WriteString(QuoteIdent(s.Name))
_, _ = buf.WriteString(" ON ")
_, _ = buf.WriteString(QuoteIdent(s.Database))
_, _ = buf.WriteString(".")
_, _ = buf.WriteString(QuoteIdent(s.RetentionPolicy))
_, _ = buf.WriteString(" DESTINATIONS ")
_, _ = buf.WriteString(s.Mode)
_, _ = buf.WriteString(" ")
for i, dest := range s.Destinations {
if i != 0 {
_, _ = buf.WriteString(", ")
}
_, _ = buf.WriteString(QuoteString(dest))
}
return buf.String()
} | [
"func",
"(",
"s",
"*",
"CreateSubscriptionStatement",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"s",
".",
"Name",
")",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"s",
".",
"Database",
")",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"s",
".",
"RetentionPolicy",
")",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"s",
".",
"Mode",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"for",
"i",
",",
"dest",
":=",
"range",
"s",
".",
"Destinations",
"{",
"if",
"i",
"!=",
"0",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteString",
"(",
"dest",
")",
")",
"\n",
"}",
"\n\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // String returns a string representation of the CreateSubscriptionStatement. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"CreateSubscriptionStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2757-L2776 |
11,012 | influxdata/influxql | ast.go | String | func (s *DropSubscriptionStatement) String() string {
return fmt.Sprintf(`DROP SUBSCRIPTION %s ON %s.%s`, QuoteIdent(s.Name), QuoteIdent(s.Database), QuoteIdent(s.RetentionPolicy))
} | go | func (s *DropSubscriptionStatement) String() string {
return fmt.Sprintf(`DROP SUBSCRIPTION %s ON %s.%s`, QuoteIdent(s.Name), QuoteIdent(s.Database), QuoteIdent(s.RetentionPolicy))
} | [
"func",
"(",
"s",
"*",
"DropSubscriptionStatement",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"`DROP SUBSCRIPTION %s ON %s.%s`",
",",
"QuoteIdent",
"(",
"s",
".",
"Name",
")",
",",
"QuoteIdent",
"(",
"s",
".",
"Database",
")",
",",
"QuoteIdent",
"(",
"s",
".",
"RetentionPolicy",
")",
")",
"\n",
"}"
] | // String returns a string representation of the DropSubscriptionStatement. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"DropSubscriptionStatement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L2796-L2798 |
11,013 | influxdata/influxql | ast.go | AliasNames | func (a Fields) AliasNames() []string {
names := []string{}
for _, f := range a {
names = append(names, f.Name())
}
return names
} | go | func (a Fields) AliasNames() []string {
names := []string{}
for _, f := range a {
names = append(names, f.Name())
}
return names
} | [
"func",
"(",
"a",
"Fields",
")",
"AliasNames",
"(",
")",
"[",
"]",
"string",
"{",
"names",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"a",
"{",
"names",
"=",
"append",
"(",
"names",
",",
"f",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"names",
"\n",
"}"
] | // AliasNames returns a list of calculated field names in
// order of alias, function name, then field. | [
"AliasNames",
"returns",
"a",
"list",
"of",
"calculated",
"field",
"names",
"in",
"order",
"of",
"alias",
"function",
"name",
"then",
"field",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3233-L3239 |
11,014 | influxdata/influxql | ast.go | Names | func (a Fields) Names() []string {
names := []string{}
for _, f := range a {
switch expr := f.Expr.(type) {
case *Call:
names = append(names, expr.Name)
case *VarRef:
names = append(names, expr.Val)
case *BinaryExpr:
names = append(names, walkNames(expr)...)
case *ParenExpr:
names = append(names, walkNames(expr)...)
}
}
return names
} | go | func (a Fields) Names() []string {
names := []string{}
for _, f := range a {
switch expr := f.Expr.(type) {
case *Call:
names = append(names, expr.Name)
case *VarRef:
names = append(names, expr.Val)
case *BinaryExpr:
names = append(names, walkNames(expr)...)
case *ParenExpr:
names = append(names, walkNames(expr)...)
}
}
return names
} | [
"func",
"(",
"a",
"Fields",
")",
"Names",
"(",
")",
"[",
"]",
"string",
"{",
"names",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"a",
"{",
"switch",
"expr",
":=",
"f",
".",
"Expr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Call",
":",
"names",
"=",
"append",
"(",
"names",
",",
"expr",
".",
"Name",
")",
"\n",
"case",
"*",
"VarRef",
":",
"names",
"=",
"append",
"(",
"names",
",",
"expr",
".",
"Val",
")",
"\n",
"case",
"*",
"BinaryExpr",
":",
"names",
"=",
"append",
"(",
"names",
",",
"walkNames",
"(",
"expr",
")",
"...",
")",
"\n",
"case",
"*",
"ParenExpr",
":",
"names",
"=",
"append",
"(",
"names",
",",
"walkNames",
"(",
"expr",
")",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"names",
"\n",
"}"
] | // Names returns a list of field names. | [
"Names",
"returns",
"a",
"list",
"of",
"field",
"names",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3242-L3257 |
11,015 | influxdata/influxql | ast.go | String | func (a Fields) String() string {
var str []string
for _, f := range a {
str = append(str, f.String())
}
return strings.Join(str, ", ")
} | go | func (a Fields) String() string {
var str []string
for _, f := range a {
str = append(str, f.String())
}
return strings.Join(str, ", ")
} | [
"func",
"(",
"a",
"Fields",
")",
"String",
"(",
")",
"string",
"{",
"var",
"str",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"a",
"{",
"str",
"=",
"append",
"(",
"str",
",",
"f",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"str",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // String returns a string representation of the fields. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"fields",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3260-L3266 |
11,016 | influxdata/influxql | ast.go | Name | func (f *Field) Name() string {
// Return alias, if set.
if f.Alias != "" {
return f.Alias
}
// Return the function name or variable name, if available.
switch expr := f.Expr.(type) {
case *Call:
return expr.Name
case *BinaryExpr:
return BinaryExprName(expr)
case *ParenExpr:
f := Field{Expr: expr.Expr}
return f.Name()
case *VarRef:
return expr.Val
}
// Otherwise return a blank name.
return ""
} | go | func (f *Field) Name() string {
// Return alias, if set.
if f.Alias != "" {
return f.Alias
}
// Return the function name or variable name, if available.
switch expr := f.Expr.(type) {
case *Call:
return expr.Name
case *BinaryExpr:
return BinaryExprName(expr)
case *ParenExpr:
f := Field{Expr: expr.Expr}
return f.Name()
case *VarRef:
return expr.Val
}
// Otherwise return a blank name.
return ""
} | [
"func",
"(",
"f",
"*",
"Field",
")",
"Name",
"(",
")",
"string",
"{",
"// Return alias, if set.",
"if",
"f",
".",
"Alias",
"!=",
"\"",
"\"",
"{",
"return",
"f",
".",
"Alias",
"\n",
"}",
"\n\n",
"// Return the function name or variable name, if available.",
"switch",
"expr",
":=",
"f",
".",
"Expr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Call",
":",
"return",
"expr",
".",
"Name",
"\n",
"case",
"*",
"BinaryExpr",
":",
"return",
"BinaryExprName",
"(",
"expr",
")",
"\n",
"case",
"*",
"ParenExpr",
":",
"f",
":=",
"Field",
"{",
"Expr",
":",
"expr",
".",
"Expr",
"}",
"\n",
"return",
"f",
".",
"Name",
"(",
")",
"\n",
"case",
"*",
"VarRef",
":",
"return",
"expr",
".",
"Val",
"\n",
"}",
"\n\n",
"// Otherwise return a blank name.",
"return",
"\"",
"\"",
"\n",
"}"
] | // Name returns the name of the field. Returns alias, if set.
// Otherwise uses the function name or variable name. | [
"Name",
"returns",
"the",
"name",
"of",
"the",
"field",
".",
"Returns",
"alias",
"if",
"set",
".",
"Otherwise",
"uses",
"the",
"function",
"name",
"or",
"variable",
"name",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3276-L3297 |
11,017 | influxdata/influxql | ast.go | String | func (f *Field) String() string {
str := f.Expr.String()
if f.Alias == "" {
return str
}
return fmt.Sprintf("%s AS %s", str, QuoteIdent(f.Alias))
} | go | func (f *Field) String() string {
str := f.Expr.String()
if f.Alias == "" {
return str
}
return fmt.Sprintf("%s AS %s", str, QuoteIdent(f.Alias))
} | [
"func",
"(",
"f",
"*",
"Field",
")",
"String",
"(",
")",
"string",
"{",
"str",
":=",
"f",
".",
"Expr",
".",
"String",
"(",
")",
"\n\n",
"if",
"f",
".",
"Alias",
"==",
"\"",
"\"",
"{",
"return",
"str",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"str",
",",
"QuoteIdent",
"(",
"f",
".",
"Alias",
")",
")",
"\n",
"}"
] | // String returns a string representation of the field. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"field",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3300-L3307 |
11,018 | influxdata/influxql | ast.go | String | func (a Dimensions) String() string {
var str []string
for _, d := range a {
str = append(str, d.String())
}
return strings.Join(str, ", ")
} | go | func (a Dimensions) String() string {
var str []string
for _, d := range a {
str = append(str, d.String())
}
return strings.Join(str, ", ")
} | [
"func",
"(",
"a",
"Dimensions",
")",
"String",
"(",
")",
"string",
"{",
"var",
"str",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"d",
":=",
"range",
"a",
"{",
"str",
"=",
"append",
"(",
"str",
",",
"d",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"str",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // String returns a string representation of the dimensions. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"dimensions",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3322-L3328 |
11,019 | influxdata/influxql | ast.go | Normalize | func (a Dimensions) Normalize() (time.Duration, []string) {
var dur time.Duration
var tags []string
for _, dim := range a {
switch expr := dim.Expr.(type) {
case *Call:
lit, _ := expr.Args[0].(*DurationLiteral)
dur = lit.Val
case *VarRef:
tags = append(tags, expr.Val)
}
}
return dur, tags
} | go | func (a Dimensions) Normalize() (time.Duration, []string) {
var dur time.Duration
var tags []string
for _, dim := range a {
switch expr := dim.Expr.(type) {
case *Call:
lit, _ := expr.Args[0].(*DurationLiteral)
dur = lit.Val
case *VarRef:
tags = append(tags, expr.Val)
}
}
return dur, tags
} | [
"func",
"(",
"a",
"Dimensions",
")",
"Normalize",
"(",
")",
"(",
"time",
".",
"Duration",
",",
"[",
"]",
"string",
")",
"{",
"var",
"dur",
"time",
".",
"Duration",
"\n",
"var",
"tags",
"[",
"]",
"string",
"\n\n",
"for",
"_",
",",
"dim",
":=",
"range",
"a",
"{",
"switch",
"expr",
":=",
"dim",
".",
"Expr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Call",
":",
"lit",
",",
"_",
":=",
"expr",
".",
"Args",
"[",
"0",
"]",
".",
"(",
"*",
"DurationLiteral",
")",
"\n",
"dur",
"=",
"lit",
".",
"Val",
"\n",
"case",
"*",
"VarRef",
":",
"tags",
"=",
"append",
"(",
"tags",
",",
"expr",
".",
"Val",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"dur",
",",
"tags",
"\n",
"}"
] | // Normalize returns the interval and tag dimensions separately.
// Returns 0 if no time interval is specified. | [
"Normalize",
"returns",
"the",
"interval",
"and",
"tag",
"dimensions",
"separately",
".",
"Returns",
"0",
"if",
"no",
"time",
"interval",
"is",
"specified",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3332-L3347 |
11,020 | influxdata/influxql | ast.go | String | func (a Measurements) String() string {
var str []string
for _, m := range a {
str = append(str, m.String())
}
return strings.Join(str, ", ")
} | go | func (a Measurements) String() string {
var str []string
for _, m := range a {
str = append(str, m.String())
}
return strings.Join(str, ", ")
} | [
"func",
"(",
"a",
"Measurements",
")",
"String",
"(",
")",
"string",
"{",
"var",
"str",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"a",
"{",
"str",
"=",
"append",
"(",
"str",
",",
"m",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"str",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // String returns a string representation of the measurements. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"measurements",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3361-L3367 |
11,021 | influxdata/influxql | ast.go | Clone | func (m *Measurement) Clone() *Measurement {
var regexp *RegexLiteral
if m.Regex != nil && m.Regex.Val != nil {
regexp = &RegexLiteral{Val: m.Regex.Val.Copy()}
}
return &Measurement{
Database: m.Database,
RetentionPolicy: m.RetentionPolicy,
Name: m.Name,
Regex: regexp,
IsTarget: m.IsTarget,
SystemIterator: m.SystemIterator,
}
} | go | func (m *Measurement) Clone() *Measurement {
var regexp *RegexLiteral
if m.Regex != nil && m.Regex.Val != nil {
regexp = &RegexLiteral{Val: m.Regex.Val.Copy()}
}
return &Measurement{
Database: m.Database,
RetentionPolicy: m.RetentionPolicy,
Name: m.Name,
Regex: regexp,
IsTarget: m.IsTarget,
SystemIterator: m.SystemIterator,
}
} | [
"func",
"(",
"m",
"*",
"Measurement",
")",
"Clone",
"(",
")",
"*",
"Measurement",
"{",
"var",
"regexp",
"*",
"RegexLiteral",
"\n",
"if",
"m",
".",
"Regex",
"!=",
"nil",
"&&",
"m",
".",
"Regex",
".",
"Val",
"!=",
"nil",
"{",
"regexp",
"=",
"&",
"RegexLiteral",
"{",
"Val",
":",
"m",
".",
"Regex",
".",
"Val",
".",
"Copy",
"(",
")",
"}",
"\n",
"}",
"\n",
"return",
"&",
"Measurement",
"{",
"Database",
":",
"m",
".",
"Database",
",",
"RetentionPolicy",
":",
"m",
".",
"RetentionPolicy",
",",
"Name",
":",
"m",
".",
"Name",
",",
"Regex",
":",
"regexp",
",",
"IsTarget",
":",
"m",
".",
"IsTarget",
",",
"SystemIterator",
":",
"m",
".",
"SystemIterator",
",",
"}",
"\n",
"}"
] | // Clone returns a deep clone of the Measurement. | [
"Clone",
"returns",
"a",
"deep",
"clone",
"of",
"the",
"Measurement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3383-L3396 |
11,022 | influxdata/influxql | ast.go | String | func (m *Measurement) String() string {
var buf bytes.Buffer
if m.Database != "" {
_, _ = buf.WriteString(QuoteIdent(m.Database))
_, _ = buf.WriteString(".")
}
if m.RetentionPolicy != "" {
_, _ = buf.WriteString(QuoteIdent(m.RetentionPolicy))
}
if m.Database != "" || m.RetentionPolicy != "" {
_, _ = buf.WriteString(`.`)
}
if m.Name != "" && m.SystemIterator == "" {
_, _ = buf.WriteString(QuoteIdent(m.Name))
} else if m.SystemIterator != "" {
_, _ = buf.WriteString(QuoteIdent(m.SystemIterator))
} else if m.Regex != nil {
_, _ = buf.WriteString(m.Regex.String())
}
return buf.String()
} | go | func (m *Measurement) String() string {
var buf bytes.Buffer
if m.Database != "" {
_, _ = buf.WriteString(QuoteIdent(m.Database))
_, _ = buf.WriteString(".")
}
if m.RetentionPolicy != "" {
_, _ = buf.WriteString(QuoteIdent(m.RetentionPolicy))
}
if m.Database != "" || m.RetentionPolicy != "" {
_, _ = buf.WriteString(`.`)
}
if m.Name != "" && m.SystemIterator == "" {
_, _ = buf.WriteString(QuoteIdent(m.Name))
} else if m.SystemIterator != "" {
_, _ = buf.WriteString(QuoteIdent(m.SystemIterator))
} else if m.Regex != nil {
_, _ = buf.WriteString(m.Regex.String())
}
return buf.String()
} | [
"func",
"(",
"m",
"*",
"Measurement",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"m",
".",
"Database",
"!=",
"\"",
"\"",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"m",
".",
"Database",
")",
")",
"\n",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"RetentionPolicy",
"!=",
"\"",
"\"",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"m",
".",
"RetentionPolicy",
")",
")",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"Database",
"!=",
"\"",
"\"",
"||",
"m",
".",
"RetentionPolicy",
"!=",
"\"",
"\"",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"`.`",
")",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"Name",
"!=",
"\"",
"\"",
"&&",
"m",
".",
"SystemIterator",
"==",
"\"",
"\"",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"m",
".",
"Name",
")",
")",
"\n",
"}",
"else",
"if",
"m",
".",
"SystemIterator",
"!=",
"\"",
"\"",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"QuoteIdent",
"(",
"m",
".",
"SystemIterator",
")",
")",
"\n",
"}",
"else",
"if",
"m",
".",
"Regex",
"!=",
"nil",
"{",
"_",
",",
"_",
"=",
"buf",
".",
"WriteString",
"(",
"m",
".",
"Regex",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // String returns a string representation of the measurement. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"measurement",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3399-L3423 |
11,023 | influxdata/influxql | ast.go | String | func (r *VarRef) String() string {
buf := bytes.NewBufferString(QuoteIdent(r.Val))
if r.Type != Unknown {
buf.WriteString("::")
buf.WriteString(r.Type.String())
}
return buf.String()
} | go | func (r *VarRef) String() string {
buf := bytes.NewBufferString(QuoteIdent(r.Val))
if r.Type != Unknown {
buf.WriteString("::")
buf.WriteString(r.Type.String())
}
return buf.String()
} | [
"func",
"(",
"r",
"*",
"VarRef",
")",
"String",
"(",
")",
"string",
"{",
"buf",
":=",
"bytes",
".",
"NewBufferString",
"(",
"QuoteIdent",
"(",
"r",
".",
"Val",
")",
")",
"\n",
"if",
"r",
".",
"Type",
"!=",
"Unknown",
"{",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"r",
".",
"Type",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // String returns a string representation of the variable reference. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"variable",
"reference",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3442-L3449 |
11,024 | influxdata/influxql | ast.go | Strings | func (a VarRefs) Strings() []string {
s := make([]string, len(a))
for i, ref := range a {
s[i] = ref.Val
}
return s
} | go | func (a VarRefs) Strings() []string {
s := make([]string, len(a))
for i, ref := range a {
s[i] = ref.Val
}
return s
} | [
"func",
"(",
"a",
"VarRefs",
")",
"Strings",
"(",
")",
"[",
"]",
"string",
"{",
"s",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"a",
")",
")",
"\n",
"for",
"i",
",",
"ref",
":=",
"range",
"a",
"{",
"s",
"[",
"i",
"]",
"=",
"ref",
".",
"Val",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // Strings returns a slice of the variable names. | [
"Strings",
"returns",
"a",
"slice",
"of",
"the",
"variable",
"names",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3469-L3475 |
11,025 | influxdata/influxql | ast.go | String | func (c *Call) String() string {
// Join arguments.
var str []string
for _, arg := range c.Args {
str = append(str, arg.String())
}
// Write function name and args.
return fmt.Sprintf("%s(%s)", c.Name, strings.Join(str, ", "))
} | go | func (c *Call) String() string {
// Join arguments.
var str []string
for _, arg := range c.Args {
str = append(str, arg.String())
}
// Write function name and args.
return fmt.Sprintf("%s(%s)", c.Name, strings.Join(str, ", "))
} | [
"func",
"(",
"c",
"*",
"Call",
")",
"String",
"(",
")",
"string",
"{",
"// Join arguments.",
"var",
"str",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"arg",
":=",
"range",
"c",
".",
"Args",
"{",
"str",
"=",
"append",
"(",
"str",
",",
"arg",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Write function name and args.",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"Name",
",",
"strings",
".",
"Join",
"(",
"str",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] | // String returns a string representation of the call. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"call",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3484-L3493 |
11,026 | influxdata/influxql | ast.go | NewCall | func (d *Distinct) NewCall() *Call {
return &Call{
Name: "distinct",
Args: []Expr{
&VarRef{Val: d.Val},
},
}
} | go | func (d *Distinct) NewCall() *Call {
return &Call{
Name: "distinct",
Args: []Expr{
&VarRef{Val: d.Val},
},
}
} | [
"func",
"(",
"d",
"*",
"Distinct",
")",
"NewCall",
"(",
")",
"*",
"Call",
"{",
"return",
"&",
"Call",
"{",
"Name",
":",
"\"",
"\"",
",",
"Args",
":",
"[",
"]",
"Expr",
"{",
"&",
"VarRef",
"{",
"Val",
":",
"d",
".",
"Val",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewCall returns a new call expression from this expressions. | [
"NewCall",
"returns",
"a",
"new",
"call",
"expression",
"from",
"this",
"expressions",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3507-L3514 |
11,027 | influxdata/influxql | ast.go | isTrueLiteral | func isTrueLiteral(expr Expr) bool {
if expr, ok := expr.(*BooleanLiteral); ok {
return expr.Val == true
}
return false
} | go | func isTrueLiteral(expr Expr) bool {
if expr, ok := expr.(*BooleanLiteral); ok {
return expr.Val == true
}
return false
} | [
"func",
"isTrueLiteral",
"(",
"expr",
"Expr",
")",
"bool",
"{",
"if",
"expr",
",",
"ok",
":=",
"expr",
".",
"(",
"*",
"BooleanLiteral",
")",
";",
"ok",
"{",
"return",
"expr",
".",
"Val",
"==",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // isTrueLiteral returns true if the expression is a literal "true" value. | [
"isTrueLiteral",
"returns",
"true",
"if",
"the",
"expression",
"is",
"a",
"literal",
"true",
"value",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3555-L3560 |
11,028 | influxdata/influxql | ast.go | isFalseLiteral | func isFalseLiteral(expr Expr) bool {
if expr, ok := expr.(*BooleanLiteral); ok {
return expr.Val == false
}
return false
} | go | func isFalseLiteral(expr Expr) bool {
if expr, ok := expr.(*BooleanLiteral); ok {
return expr.Val == false
}
return false
} | [
"func",
"isFalseLiteral",
"(",
"expr",
"Expr",
")",
"bool",
"{",
"if",
"expr",
",",
"ok",
":=",
"expr",
".",
"(",
"*",
"BooleanLiteral",
")",
";",
"ok",
"{",
"return",
"expr",
".",
"Val",
"==",
"false",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // isFalseLiteral returns true if the expression is a literal "false" value. | [
"isFalseLiteral",
"returns",
"true",
"if",
"the",
"expression",
"is",
"a",
"literal",
"false",
"value",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3563-L3568 |
11,029 | influxdata/influxql | ast.go | IsTimeLiteral | func (l *StringLiteral) IsTimeLiteral() bool {
return isDateTimeString(l.Val) || isDateString(l.Val)
} | go | func (l *StringLiteral) IsTimeLiteral() bool {
return isDateTimeString(l.Val) || isDateString(l.Val)
} | [
"func",
"(",
"l",
"*",
"StringLiteral",
")",
"IsTimeLiteral",
"(",
")",
"bool",
"{",
"return",
"isDateTimeString",
"(",
"l",
".",
"Val",
")",
"||",
"isDateString",
"(",
"l",
".",
"Val",
")",
"\n",
"}"
] | // IsTimeLiteral returns if this string can be interpreted as a time literal. | [
"IsTimeLiteral",
"returns",
"if",
"this",
"string",
"can",
"be",
"interpreted",
"as",
"a",
"time",
"literal",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3598-L3600 |
11,030 | influxdata/influxql | ast.go | ToTimeLiteral | func (l *StringLiteral) ToTimeLiteral(loc *time.Location) (*TimeLiteral, error) {
if loc == nil {
loc = time.UTC
}
if isDateTimeString(l.Val) {
t, err := time.ParseInLocation(DateTimeFormat, l.Val, loc)
if err != nil {
// try to parse it as an RFCNano time
t, err = time.ParseInLocation(time.RFC3339Nano, l.Val, loc)
if err != nil {
return nil, ErrInvalidTime
}
}
return &TimeLiteral{Val: t}, nil
} else if isDateString(l.Val) {
t, err := time.ParseInLocation(DateFormat, l.Val, loc)
if err != nil {
return nil, ErrInvalidTime
}
return &TimeLiteral{Val: t}, nil
}
return nil, ErrInvalidTime
} | go | func (l *StringLiteral) ToTimeLiteral(loc *time.Location) (*TimeLiteral, error) {
if loc == nil {
loc = time.UTC
}
if isDateTimeString(l.Val) {
t, err := time.ParseInLocation(DateTimeFormat, l.Val, loc)
if err != nil {
// try to parse it as an RFCNano time
t, err = time.ParseInLocation(time.RFC3339Nano, l.Val, loc)
if err != nil {
return nil, ErrInvalidTime
}
}
return &TimeLiteral{Val: t}, nil
} else if isDateString(l.Val) {
t, err := time.ParseInLocation(DateFormat, l.Val, loc)
if err != nil {
return nil, ErrInvalidTime
}
return &TimeLiteral{Val: t}, nil
}
return nil, ErrInvalidTime
} | [
"func",
"(",
"l",
"*",
"StringLiteral",
")",
"ToTimeLiteral",
"(",
"loc",
"*",
"time",
".",
"Location",
")",
"(",
"*",
"TimeLiteral",
",",
"error",
")",
"{",
"if",
"loc",
"==",
"nil",
"{",
"loc",
"=",
"time",
".",
"UTC",
"\n",
"}",
"\n\n",
"if",
"isDateTimeString",
"(",
"l",
".",
"Val",
")",
"{",
"t",
",",
"err",
":=",
"time",
".",
"ParseInLocation",
"(",
"DateTimeFormat",
",",
"l",
".",
"Val",
",",
"loc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// try to parse it as an RFCNano time",
"t",
",",
"err",
"=",
"time",
".",
"ParseInLocation",
"(",
"time",
".",
"RFC3339Nano",
",",
"l",
".",
"Val",
",",
"loc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrInvalidTime",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"TimeLiteral",
"{",
"Val",
":",
"t",
"}",
",",
"nil",
"\n",
"}",
"else",
"if",
"isDateString",
"(",
"l",
".",
"Val",
")",
"{",
"t",
",",
"err",
":=",
"time",
".",
"ParseInLocation",
"(",
"DateFormat",
",",
"l",
".",
"Val",
",",
"loc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ErrInvalidTime",
"\n",
"}",
"\n",
"return",
"&",
"TimeLiteral",
"{",
"Val",
":",
"t",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"ErrInvalidTime",
"\n",
"}"
] | // ToTimeLiteral returns a time literal if this string can be converted to a time literal. | [
"ToTimeLiteral",
"returns",
"a",
"time",
"literal",
"if",
"this",
"string",
"can",
"be",
"converted",
"to",
"a",
"time",
"literal",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3603-L3626 |
11,031 | influxdata/influxql | ast.go | String | func (e *BinaryExpr) String() string {
return fmt.Sprintf("%s %s %s", e.LHS.String(), e.Op.String(), e.RHS.String())
} | go | func (e *BinaryExpr) String() string {
return fmt.Sprintf("%s %s %s", e.LHS.String(), e.Op.String(), e.RHS.String())
} | [
"func",
"(",
"e",
"*",
"BinaryExpr",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"LHS",
".",
"String",
"(",
")",
",",
"e",
".",
"Op",
".",
"String",
"(",
")",
",",
"e",
".",
"RHS",
".",
"String",
"(",
")",
")",
"\n",
"}"
] | // String returns a string representation of the binary expression. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"binary",
"expression",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3673-L3675 |
11,032 | influxdata/influxql | ast.go | BinaryExprName | func BinaryExprName(expr *BinaryExpr) string {
v := binaryExprNameVisitor{}
Walk(&v, expr)
return strings.Join(v.names, "_")
} | go | func BinaryExprName(expr *BinaryExpr) string {
v := binaryExprNameVisitor{}
Walk(&v, expr)
return strings.Join(v.names, "_")
} | [
"func",
"BinaryExprName",
"(",
"expr",
"*",
"BinaryExpr",
")",
"string",
"{",
"v",
":=",
"binaryExprNameVisitor",
"{",
"}",
"\n",
"Walk",
"(",
"&",
"v",
",",
"expr",
")",
"\n",
"return",
"strings",
".",
"Join",
"(",
"v",
".",
"names",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // BinaryExprName returns the name of a binary expression by concatenating
// the variables in the binary expression with underscores. | [
"BinaryExprName",
"returns",
"the",
"name",
"of",
"a",
"binary",
"expression",
"by",
"concatenating",
"the",
"variables",
"in",
"the",
"binary",
"expression",
"with",
"underscores",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3679-L3683 |
11,033 | influxdata/influxql | ast.go | CloneRegexLiteral | func CloneRegexLiteral(r *RegexLiteral) *RegexLiteral {
if r == nil {
return nil
}
clone := &RegexLiteral{}
if r.Val != nil {
clone.Val = regexp.MustCompile(r.Val.String())
}
return clone
} | go | func CloneRegexLiteral(r *RegexLiteral) *RegexLiteral {
if r == nil {
return nil
}
clone := &RegexLiteral{}
if r.Val != nil {
clone.Val = regexp.MustCompile(r.Val.String())
}
return clone
} | [
"func",
"CloneRegexLiteral",
"(",
"r",
"*",
"RegexLiteral",
")",
"*",
"RegexLiteral",
"{",
"if",
"r",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"clone",
":=",
"&",
"RegexLiteral",
"{",
"}",
"\n",
"if",
"r",
".",
"Val",
"!=",
"nil",
"{",
"clone",
".",
"Val",
"=",
"regexp",
".",
"MustCompile",
"(",
"r",
".",
"Val",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"clone",
"\n",
"}"
] | // CloneRegexLiteral returns a clone of the RegexLiteral. | [
"CloneRegexLiteral",
"returns",
"a",
"clone",
"of",
"the",
"RegexLiteral",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3722-L3733 |
11,034 | influxdata/influxql | ast.go | CloneExpr | func CloneExpr(expr Expr) Expr {
if expr == nil {
return nil
}
switch expr := expr.(type) {
case *BinaryExpr:
return &BinaryExpr{Op: expr.Op, LHS: CloneExpr(expr.LHS), RHS: CloneExpr(expr.RHS)}
case *BooleanLiteral:
return &BooleanLiteral{Val: expr.Val}
case *Call:
args := make([]Expr, len(expr.Args))
for i, arg := range expr.Args {
args[i] = CloneExpr(arg)
}
return &Call{Name: expr.Name, Args: args}
case *Distinct:
return &Distinct{Val: expr.Val}
case *DurationLiteral:
return &DurationLiteral{Val: expr.Val}
case *IntegerLiteral:
return &IntegerLiteral{Val: expr.Val}
case *UnsignedLiteral:
return &UnsignedLiteral{Val: expr.Val}
case *NumberLiteral:
return &NumberLiteral{Val: expr.Val}
case *ParenExpr:
return &ParenExpr{Expr: CloneExpr(expr.Expr)}
case *RegexLiteral:
return &RegexLiteral{Val: expr.Val}
case *StringLiteral:
return &StringLiteral{Val: expr.Val}
case *TimeLiteral:
return &TimeLiteral{Val: expr.Val}
case *VarRef:
return &VarRef{Val: expr.Val, Type: expr.Type}
case *Wildcard:
return &Wildcard{Type: expr.Type}
}
panic("unreachable")
} | go | func CloneExpr(expr Expr) Expr {
if expr == nil {
return nil
}
switch expr := expr.(type) {
case *BinaryExpr:
return &BinaryExpr{Op: expr.Op, LHS: CloneExpr(expr.LHS), RHS: CloneExpr(expr.RHS)}
case *BooleanLiteral:
return &BooleanLiteral{Val: expr.Val}
case *Call:
args := make([]Expr, len(expr.Args))
for i, arg := range expr.Args {
args[i] = CloneExpr(arg)
}
return &Call{Name: expr.Name, Args: args}
case *Distinct:
return &Distinct{Val: expr.Val}
case *DurationLiteral:
return &DurationLiteral{Val: expr.Val}
case *IntegerLiteral:
return &IntegerLiteral{Val: expr.Val}
case *UnsignedLiteral:
return &UnsignedLiteral{Val: expr.Val}
case *NumberLiteral:
return &NumberLiteral{Val: expr.Val}
case *ParenExpr:
return &ParenExpr{Expr: CloneExpr(expr.Expr)}
case *RegexLiteral:
return &RegexLiteral{Val: expr.Val}
case *StringLiteral:
return &StringLiteral{Val: expr.Val}
case *TimeLiteral:
return &TimeLiteral{Val: expr.Val}
case *VarRef:
return &VarRef{Val: expr.Val, Type: expr.Type}
case *Wildcard:
return &Wildcard{Type: expr.Type}
}
panic("unreachable")
} | [
"func",
"CloneExpr",
"(",
"expr",
"Expr",
")",
"Expr",
"{",
"if",
"expr",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"switch",
"expr",
":=",
"expr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"BinaryExpr",
":",
"return",
"&",
"BinaryExpr",
"{",
"Op",
":",
"expr",
".",
"Op",
",",
"LHS",
":",
"CloneExpr",
"(",
"expr",
".",
"LHS",
")",
",",
"RHS",
":",
"CloneExpr",
"(",
"expr",
".",
"RHS",
")",
"}",
"\n",
"case",
"*",
"BooleanLiteral",
":",
"return",
"&",
"BooleanLiteral",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"Call",
":",
"args",
":=",
"make",
"(",
"[",
"]",
"Expr",
",",
"len",
"(",
"expr",
".",
"Args",
")",
")",
"\n",
"for",
"i",
",",
"arg",
":=",
"range",
"expr",
".",
"Args",
"{",
"args",
"[",
"i",
"]",
"=",
"CloneExpr",
"(",
"arg",
")",
"\n",
"}",
"\n",
"return",
"&",
"Call",
"{",
"Name",
":",
"expr",
".",
"Name",
",",
"Args",
":",
"args",
"}",
"\n",
"case",
"*",
"Distinct",
":",
"return",
"&",
"Distinct",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"DurationLiteral",
":",
"return",
"&",
"DurationLiteral",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"IntegerLiteral",
":",
"return",
"&",
"IntegerLiteral",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"UnsignedLiteral",
":",
"return",
"&",
"UnsignedLiteral",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"NumberLiteral",
":",
"return",
"&",
"NumberLiteral",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"ParenExpr",
":",
"return",
"&",
"ParenExpr",
"{",
"Expr",
":",
"CloneExpr",
"(",
"expr",
".",
"Expr",
")",
"}",
"\n",
"case",
"*",
"RegexLiteral",
":",
"return",
"&",
"RegexLiteral",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"StringLiteral",
":",
"return",
"&",
"StringLiteral",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"TimeLiteral",
":",
"return",
"&",
"TimeLiteral",
"{",
"Val",
":",
"expr",
".",
"Val",
"}",
"\n",
"case",
"*",
"VarRef",
":",
"return",
"&",
"VarRef",
"{",
"Val",
":",
"expr",
".",
"Val",
",",
"Type",
":",
"expr",
".",
"Type",
"}",
"\n",
"case",
"*",
"Wildcard",
":",
"return",
"&",
"Wildcard",
"{",
"Type",
":",
"expr",
".",
"Type",
"}",
"\n",
"}",
"\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // CloneExpr returns a deep copy of the expression. | [
"CloneExpr",
"returns",
"a",
"deep",
"copy",
"of",
"the",
"expression",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3753-L3792 |
11,035 | influxdata/influxql | ast.go | HasTimeExpr | func HasTimeExpr(expr Expr) bool {
switch n := expr.(type) {
case *BinaryExpr:
if n.Op == AND || n.Op == OR {
return HasTimeExpr(n.LHS) || HasTimeExpr(n.RHS)
}
if ref, ok := n.LHS.(*VarRef); ok && strings.ToLower(ref.Val) == "time" {
return true
}
return false
case *ParenExpr:
// walk down the tree
return HasTimeExpr(n.Expr)
default:
return false
}
} | go | func HasTimeExpr(expr Expr) bool {
switch n := expr.(type) {
case *BinaryExpr:
if n.Op == AND || n.Op == OR {
return HasTimeExpr(n.LHS) || HasTimeExpr(n.RHS)
}
if ref, ok := n.LHS.(*VarRef); ok && strings.ToLower(ref.Val) == "time" {
return true
}
return false
case *ParenExpr:
// walk down the tree
return HasTimeExpr(n.Expr)
default:
return false
}
} | [
"func",
"HasTimeExpr",
"(",
"expr",
"Expr",
")",
"bool",
"{",
"switch",
"n",
":=",
"expr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"BinaryExpr",
":",
"if",
"n",
".",
"Op",
"==",
"AND",
"||",
"n",
".",
"Op",
"==",
"OR",
"{",
"return",
"HasTimeExpr",
"(",
"n",
".",
"LHS",
")",
"||",
"HasTimeExpr",
"(",
"n",
".",
"RHS",
")",
"\n",
"}",
"\n",
"if",
"ref",
",",
"ok",
":=",
"n",
".",
"LHS",
".",
"(",
"*",
"VarRef",
")",
";",
"ok",
"&&",
"strings",
".",
"ToLower",
"(",
"ref",
".",
"Val",
")",
"==",
"\"",
"\"",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"case",
"*",
"ParenExpr",
":",
"// walk down the tree",
"return",
"HasTimeExpr",
"(",
"n",
".",
"Expr",
")",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // HasTimeExpr returns true if the expression has a time term. | [
"HasTimeExpr",
"returns",
"true",
"if",
"the",
"expression",
"has",
"a",
"time",
"term",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3795-L3811 |
11,036 | influxdata/influxql | ast.go | Rewrite | func Rewrite(r Rewriter, node Node) Node {
switch n := node.(type) {
case *Query:
n.Statements = Rewrite(r, n.Statements).(Statements)
case Statements:
for i, s := range n {
n[i] = Rewrite(r, s).(Statement)
}
case *SelectStatement:
n.Fields = Rewrite(r, n.Fields).(Fields)
n.Dimensions = Rewrite(r, n.Dimensions).(Dimensions)
n.Sources = Rewrite(r, n.Sources).(Sources)
// Rewrite may return nil. Nil does not satisfy the Expr
// interface. We only assert the rewritten result to be an
// Expr if it is not nil:
if cond := Rewrite(r, n.Condition); cond != nil {
n.Condition = cond.(Expr)
} else {
n.Condition = nil
}
case *SubQuery:
n.Statement = Rewrite(r, n.Statement).(*SelectStatement)
case Fields:
for i, f := range n {
n[i] = Rewrite(r, f).(*Field)
}
case *Field:
n.Expr = Rewrite(r, n.Expr).(Expr)
case Dimensions:
for i, d := range n {
n[i] = Rewrite(r, d).(*Dimension)
}
case *Dimension:
n.Expr = Rewrite(r, n.Expr).(Expr)
case *BinaryExpr:
n.LHS = Rewrite(r, n.LHS).(Expr)
n.RHS = Rewrite(r, n.RHS).(Expr)
case *ParenExpr:
n.Expr = Rewrite(r, n.Expr).(Expr)
case *Call:
for i, expr := range n.Args {
n.Args[i] = Rewrite(r, expr).(Expr)
}
}
return r.Rewrite(node)
} | go | func Rewrite(r Rewriter, node Node) Node {
switch n := node.(type) {
case *Query:
n.Statements = Rewrite(r, n.Statements).(Statements)
case Statements:
for i, s := range n {
n[i] = Rewrite(r, s).(Statement)
}
case *SelectStatement:
n.Fields = Rewrite(r, n.Fields).(Fields)
n.Dimensions = Rewrite(r, n.Dimensions).(Dimensions)
n.Sources = Rewrite(r, n.Sources).(Sources)
// Rewrite may return nil. Nil does not satisfy the Expr
// interface. We only assert the rewritten result to be an
// Expr if it is not nil:
if cond := Rewrite(r, n.Condition); cond != nil {
n.Condition = cond.(Expr)
} else {
n.Condition = nil
}
case *SubQuery:
n.Statement = Rewrite(r, n.Statement).(*SelectStatement)
case Fields:
for i, f := range n {
n[i] = Rewrite(r, f).(*Field)
}
case *Field:
n.Expr = Rewrite(r, n.Expr).(Expr)
case Dimensions:
for i, d := range n {
n[i] = Rewrite(r, d).(*Dimension)
}
case *Dimension:
n.Expr = Rewrite(r, n.Expr).(Expr)
case *BinaryExpr:
n.LHS = Rewrite(r, n.LHS).(Expr)
n.RHS = Rewrite(r, n.RHS).(Expr)
case *ParenExpr:
n.Expr = Rewrite(r, n.Expr).(Expr)
case *Call:
for i, expr := range n.Args {
n.Args[i] = Rewrite(r, expr).(Expr)
}
}
return r.Rewrite(node)
} | [
"func",
"Rewrite",
"(",
"r",
"Rewriter",
",",
"node",
"Node",
")",
"Node",
"{",
"switch",
"n",
":=",
"node",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Query",
":",
"n",
".",
"Statements",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Statements",
")",
".",
"(",
"Statements",
")",
"\n\n",
"case",
"Statements",
":",
"for",
"i",
",",
"s",
":=",
"range",
"n",
"{",
"n",
"[",
"i",
"]",
"=",
"Rewrite",
"(",
"r",
",",
"s",
")",
".",
"(",
"Statement",
")",
"\n",
"}",
"\n\n",
"case",
"*",
"SelectStatement",
":",
"n",
".",
"Fields",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Fields",
")",
".",
"(",
"Fields",
")",
"\n",
"n",
".",
"Dimensions",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Dimensions",
")",
".",
"(",
"Dimensions",
")",
"\n",
"n",
".",
"Sources",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Sources",
")",
".",
"(",
"Sources",
")",
"\n\n",
"// Rewrite may return nil. Nil does not satisfy the Expr",
"// interface. We only assert the rewritten result to be an",
"// Expr if it is not nil:",
"if",
"cond",
":=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Condition",
")",
";",
"cond",
"!=",
"nil",
"{",
"n",
".",
"Condition",
"=",
"cond",
".",
"(",
"Expr",
")",
"\n",
"}",
"else",
"{",
"n",
".",
"Condition",
"=",
"nil",
"\n",
"}",
"\n\n",
"case",
"*",
"SubQuery",
":",
"n",
".",
"Statement",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Statement",
")",
".",
"(",
"*",
"SelectStatement",
")",
"\n\n",
"case",
"Fields",
":",
"for",
"i",
",",
"f",
":=",
"range",
"n",
"{",
"n",
"[",
"i",
"]",
"=",
"Rewrite",
"(",
"r",
",",
"f",
")",
".",
"(",
"*",
"Field",
")",
"\n",
"}",
"\n\n",
"case",
"*",
"Field",
":",
"n",
".",
"Expr",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Expr",
")",
".",
"(",
"Expr",
")",
"\n\n",
"case",
"Dimensions",
":",
"for",
"i",
",",
"d",
":=",
"range",
"n",
"{",
"n",
"[",
"i",
"]",
"=",
"Rewrite",
"(",
"r",
",",
"d",
")",
".",
"(",
"*",
"Dimension",
")",
"\n",
"}",
"\n\n",
"case",
"*",
"Dimension",
":",
"n",
".",
"Expr",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Expr",
")",
".",
"(",
"Expr",
")",
"\n\n",
"case",
"*",
"BinaryExpr",
":",
"n",
".",
"LHS",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"LHS",
")",
".",
"(",
"Expr",
")",
"\n",
"n",
".",
"RHS",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"RHS",
")",
".",
"(",
"Expr",
")",
"\n\n",
"case",
"*",
"ParenExpr",
":",
"n",
".",
"Expr",
"=",
"Rewrite",
"(",
"r",
",",
"n",
".",
"Expr",
")",
".",
"(",
"Expr",
")",
"\n\n",
"case",
"*",
"Call",
":",
"for",
"i",
",",
"expr",
":=",
"range",
"n",
".",
"Args",
"{",
"n",
".",
"Args",
"[",
"i",
"]",
"=",
"Rewrite",
"(",
"r",
",",
"expr",
")",
".",
"(",
"Expr",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"r",
".",
"Rewrite",
"(",
"node",
")",
"\n",
"}"
] | // Rewrite recursively invokes the rewriter to replace each node.
// Nodes are traversed depth-first and rewritten from leaf to root. | [
"Rewrite",
"recursively",
"invokes",
"the",
"rewriter",
"to",
"replace",
"each",
"node",
".",
"Nodes",
"are",
"traversed",
"depth",
"-",
"first",
"and",
"rewritten",
"from",
"leaf",
"to",
"root",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L3963-L4020 |
11,037 | influxdata/influxql | ast.go | RewriteFunc | func RewriteFunc(node Node, fn func(Node) Node) Node {
return Rewrite(rewriterFunc(fn), node)
} | go | func RewriteFunc(node Node, fn func(Node) Node) Node {
return Rewrite(rewriterFunc(fn), node)
} | [
"func",
"RewriteFunc",
"(",
"node",
"Node",
",",
"fn",
"func",
"(",
"Node",
")",
"Node",
")",
"Node",
"{",
"return",
"Rewrite",
"(",
"rewriterFunc",
"(",
"fn",
")",
",",
"node",
")",
"\n",
"}"
] | // RewriteFunc rewrites a node hierarchy. | [
"RewriteFunc",
"rewrites",
"a",
"node",
"hierarchy",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L4023-L4025 |
11,038 | influxdata/influxql | ast.go | RewriteExpr | func RewriteExpr(expr Expr, fn func(Expr) Expr) Expr {
switch e := expr.(type) {
case *BinaryExpr:
e.LHS = RewriteExpr(e.LHS, fn)
e.RHS = RewriteExpr(e.RHS, fn)
if e.LHS != nil && e.RHS == nil {
expr = e.LHS
} else if e.RHS != nil && e.LHS == nil {
expr = e.RHS
} else if e.LHS == nil && e.RHS == nil {
return nil
}
case *ParenExpr:
e.Expr = RewriteExpr(e.Expr, fn)
if e.Expr == nil {
return nil
}
case *Call:
for i, expr := range e.Args {
e.Args[i] = RewriteExpr(expr, fn)
}
}
return fn(expr)
} | go | func RewriteExpr(expr Expr, fn func(Expr) Expr) Expr {
switch e := expr.(type) {
case *BinaryExpr:
e.LHS = RewriteExpr(e.LHS, fn)
e.RHS = RewriteExpr(e.RHS, fn)
if e.LHS != nil && e.RHS == nil {
expr = e.LHS
} else if e.RHS != nil && e.LHS == nil {
expr = e.RHS
} else if e.LHS == nil && e.RHS == nil {
return nil
}
case *ParenExpr:
e.Expr = RewriteExpr(e.Expr, fn)
if e.Expr == nil {
return nil
}
case *Call:
for i, expr := range e.Args {
e.Args[i] = RewriteExpr(expr, fn)
}
}
return fn(expr)
} | [
"func",
"RewriteExpr",
"(",
"expr",
"Expr",
",",
"fn",
"func",
"(",
"Expr",
")",
"Expr",
")",
"Expr",
"{",
"switch",
"e",
":=",
"expr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"BinaryExpr",
":",
"e",
".",
"LHS",
"=",
"RewriteExpr",
"(",
"e",
".",
"LHS",
",",
"fn",
")",
"\n",
"e",
".",
"RHS",
"=",
"RewriteExpr",
"(",
"e",
".",
"RHS",
",",
"fn",
")",
"\n",
"if",
"e",
".",
"LHS",
"!=",
"nil",
"&&",
"e",
".",
"RHS",
"==",
"nil",
"{",
"expr",
"=",
"e",
".",
"LHS",
"\n",
"}",
"else",
"if",
"e",
".",
"RHS",
"!=",
"nil",
"&&",
"e",
".",
"LHS",
"==",
"nil",
"{",
"expr",
"=",
"e",
".",
"RHS",
"\n",
"}",
"else",
"if",
"e",
".",
"LHS",
"==",
"nil",
"&&",
"e",
".",
"RHS",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"case",
"*",
"ParenExpr",
":",
"e",
".",
"Expr",
"=",
"RewriteExpr",
"(",
"e",
".",
"Expr",
",",
"fn",
")",
"\n",
"if",
"e",
".",
"Expr",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"case",
"*",
"Call",
":",
"for",
"i",
",",
"expr",
":=",
"range",
"e",
".",
"Args",
"{",
"e",
".",
"Args",
"[",
"i",
"]",
"=",
"RewriteExpr",
"(",
"expr",
",",
"fn",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"fn",
"(",
"expr",
")",
"\n",
"}"
] | // RewriteExpr recursively invokes the function to replace each expr.
// Nodes are traversed depth-first and rewritten from leaf to root. | [
"RewriteExpr",
"recursively",
"invokes",
"the",
"function",
"to",
"replace",
"each",
"expr",
".",
"Nodes",
"are",
"traversed",
"depth",
"-",
"first",
"and",
"rewritten",
"from",
"leaf",
"to",
"root",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L4033-L4059 |
11,039 | influxdata/influxql | ast.go | Eval | func Eval(expr Expr, m map[string]interface{}) interface{} {
eval := ValuerEval{Valuer: MapValuer(m)}
return eval.Eval(expr)
} | go | func Eval(expr Expr, m map[string]interface{}) interface{} {
eval := ValuerEval{Valuer: MapValuer(m)}
return eval.Eval(expr)
} | [
"func",
"Eval",
"(",
"expr",
"Expr",
",",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"eval",
":=",
"ValuerEval",
"{",
"Valuer",
":",
"MapValuer",
"(",
"m",
")",
"}",
"\n",
"return",
"eval",
".",
"Eval",
"(",
"expr",
")",
"\n",
"}"
] | // Eval evaluates expr against a map. | [
"Eval",
"evaluates",
"expr",
"against",
"a",
"map",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L4062-L4065 |
11,040 | influxdata/influxql | ast.go | Value | func (m MapValuer) Value(key string) (interface{}, bool) {
v, ok := m[key]
return v, ok
} | go | func (m MapValuer) Value(key string) (interface{}, bool) {
v, ok := m[key]
return v, ok
} | [
"func",
"(",
"m",
"MapValuer",
")",
"Value",
"(",
"key",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"v",
",",
"ok",
":=",
"m",
"[",
"key",
"]",
"\n",
"return",
"v",
",",
"ok",
"\n",
"}"
] | // Value returns the value for a key in the MapValuer. | [
"Value",
"returns",
"the",
"value",
"for",
"a",
"key",
"in",
"the",
"MapValuer",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L4071-L4074 |
11,041 | influxdata/influxql | ast.go | Eval | func (v *ValuerEval) Eval(expr Expr) interface{} {
if expr == nil {
return nil
}
switch expr := expr.(type) {
case *BinaryExpr:
return v.evalBinaryExpr(expr)
case *BooleanLiteral:
return expr.Val
case *IntegerLiteral:
return expr.Val
case *NumberLiteral:
return expr.Val
case *UnsignedLiteral:
return expr.Val
case *ParenExpr:
return v.Eval(expr.Expr)
case *RegexLiteral:
return expr.Val
case *StringLiteral:
return expr.Val
case *Call:
if valuer, ok := v.Valuer.(CallValuer); ok {
var args []interface{}
if len(expr.Args) > 0 {
args = make([]interface{}, len(expr.Args))
for i := range expr.Args {
args[i] = v.Eval(expr.Args[i])
}
}
val, _ := valuer.Call(expr.Name, args)
return val
}
return nil
case *VarRef:
val, _ := v.Valuer.Value(expr.Val)
return val
default:
return nil
}
} | go | func (v *ValuerEval) Eval(expr Expr) interface{} {
if expr == nil {
return nil
}
switch expr := expr.(type) {
case *BinaryExpr:
return v.evalBinaryExpr(expr)
case *BooleanLiteral:
return expr.Val
case *IntegerLiteral:
return expr.Val
case *NumberLiteral:
return expr.Val
case *UnsignedLiteral:
return expr.Val
case *ParenExpr:
return v.Eval(expr.Expr)
case *RegexLiteral:
return expr.Val
case *StringLiteral:
return expr.Val
case *Call:
if valuer, ok := v.Valuer.(CallValuer); ok {
var args []interface{}
if len(expr.Args) > 0 {
args = make([]interface{}, len(expr.Args))
for i := range expr.Args {
args[i] = v.Eval(expr.Args[i])
}
}
val, _ := valuer.Call(expr.Name, args)
return val
}
return nil
case *VarRef:
val, _ := v.Valuer.Value(expr.Val)
return val
default:
return nil
}
} | [
"func",
"(",
"v",
"*",
"ValuerEval",
")",
"Eval",
"(",
"expr",
"Expr",
")",
"interface",
"{",
"}",
"{",
"if",
"expr",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"switch",
"expr",
":=",
"expr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"BinaryExpr",
":",
"return",
"v",
".",
"evalBinaryExpr",
"(",
"expr",
")",
"\n",
"case",
"*",
"BooleanLiteral",
":",
"return",
"expr",
".",
"Val",
"\n",
"case",
"*",
"IntegerLiteral",
":",
"return",
"expr",
".",
"Val",
"\n",
"case",
"*",
"NumberLiteral",
":",
"return",
"expr",
".",
"Val",
"\n",
"case",
"*",
"UnsignedLiteral",
":",
"return",
"expr",
".",
"Val",
"\n",
"case",
"*",
"ParenExpr",
":",
"return",
"v",
".",
"Eval",
"(",
"expr",
".",
"Expr",
")",
"\n",
"case",
"*",
"RegexLiteral",
":",
"return",
"expr",
".",
"Val",
"\n",
"case",
"*",
"StringLiteral",
":",
"return",
"expr",
".",
"Val",
"\n",
"case",
"*",
"Call",
":",
"if",
"valuer",
",",
"ok",
":=",
"v",
".",
"Valuer",
".",
"(",
"CallValuer",
")",
";",
"ok",
"{",
"var",
"args",
"[",
"]",
"interface",
"{",
"}",
"\n",
"if",
"len",
"(",
"expr",
".",
"Args",
")",
">",
"0",
"{",
"args",
"=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"expr",
".",
"Args",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"expr",
".",
"Args",
"{",
"args",
"[",
"i",
"]",
"=",
"v",
".",
"Eval",
"(",
"expr",
".",
"Args",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"val",
",",
"_",
":=",
"valuer",
".",
"Call",
"(",
"expr",
".",
"Name",
",",
"args",
")",
"\n",
"return",
"val",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"case",
"*",
"VarRef",
":",
"val",
",",
"_",
":=",
"v",
".",
"Valuer",
".",
"Value",
"(",
"expr",
".",
"Val",
")",
"\n",
"return",
"val",
"\n",
"default",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Eval evaluates an expression and returns a value. | [
"Eval",
"evaluates",
"an",
"expression",
"and",
"returns",
"a",
"value",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L4086-L4127 |
11,042 | influxdata/influxql | ast.go | EvalType | func (v *TypeValuerEval) EvalType(expr Expr) (DataType, error) {
switch expr := expr.(type) {
case *VarRef:
return v.evalVarRefExprType(expr)
case *Call:
return v.evalCallExprType(expr)
case *BinaryExpr:
return v.evalBinaryExprType(expr)
case *ParenExpr:
return v.EvalType(expr.Expr)
case *NumberLiteral:
return Float, nil
case *IntegerLiteral:
return Integer, nil
case *UnsignedLiteral:
return Unsigned, nil
case *StringLiteral:
return String, nil
case *BooleanLiteral:
return Boolean, nil
}
return Unknown, nil
} | go | func (v *TypeValuerEval) EvalType(expr Expr) (DataType, error) {
switch expr := expr.(type) {
case *VarRef:
return v.evalVarRefExprType(expr)
case *Call:
return v.evalCallExprType(expr)
case *BinaryExpr:
return v.evalBinaryExprType(expr)
case *ParenExpr:
return v.EvalType(expr.Expr)
case *NumberLiteral:
return Float, nil
case *IntegerLiteral:
return Integer, nil
case *UnsignedLiteral:
return Unsigned, nil
case *StringLiteral:
return String, nil
case *BooleanLiteral:
return Boolean, nil
}
return Unknown, nil
} | [
"func",
"(",
"v",
"*",
"TypeValuerEval",
")",
"EvalType",
"(",
"expr",
"Expr",
")",
"(",
"DataType",
",",
"error",
")",
"{",
"switch",
"expr",
":=",
"expr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"VarRef",
":",
"return",
"v",
".",
"evalVarRefExprType",
"(",
"expr",
")",
"\n",
"case",
"*",
"Call",
":",
"return",
"v",
".",
"evalCallExprType",
"(",
"expr",
")",
"\n",
"case",
"*",
"BinaryExpr",
":",
"return",
"v",
".",
"evalBinaryExprType",
"(",
"expr",
")",
"\n",
"case",
"*",
"ParenExpr",
":",
"return",
"v",
".",
"EvalType",
"(",
"expr",
".",
"Expr",
")",
"\n",
"case",
"*",
"NumberLiteral",
":",
"return",
"Float",
",",
"nil",
"\n",
"case",
"*",
"IntegerLiteral",
":",
"return",
"Integer",
",",
"nil",
"\n",
"case",
"*",
"UnsignedLiteral",
":",
"return",
"Unsigned",
",",
"nil",
"\n",
"case",
"*",
"StringLiteral",
":",
"return",
"String",
",",
"nil",
"\n",
"case",
"*",
"BooleanLiteral",
":",
"return",
"Boolean",
",",
"nil",
"\n",
"}",
"\n",
"return",
"Unknown",
",",
"nil",
"\n",
"}"
] | // EvalType returns the type for an expression. If the expression cannot
// be evaluated for some reason, like incompatible types, it is returned
// as a TypeError in the error. If the error is non-fatal so we can continue
// even though an error happened, true will be returned.
// This function assumes that the expression has already been reduced. | [
"EvalType",
"returns",
"the",
"type",
"for",
"an",
"expression",
".",
"If",
"the",
"expression",
"cannot",
"be",
"evaluated",
"for",
"some",
"reason",
"like",
"incompatible",
"types",
"it",
"is",
"returned",
"as",
"a",
"TypeError",
"in",
"the",
"error",
".",
"If",
"the",
"error",
"is",
"non",
"-",
"fatal",
"so",
"we",
"can",
"continue",
"even",
"though",
"an",
"error",
"happened",
"true",
"will",
"be",
"returned",
".",
"This",
"function",
"assumes",
"that",
"the",
"expression",
"has",
"already",
"been",
"reduced",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L4576-L4598 |
11,043 | influxdata/influxql | ast.go | EvalType | func EvalType(expr Expr, sources Sources, typmap TypeMapper) DataType {
if typmap == nil {
typmap = nilTypeMapper{}
}
valuer := TypeValuerEval{
TypeMapper: typmap,
Sources: sources,
}
typ, _ := valuer.EvalType(expr)
return typ
} | go | func EvalType(expr Expr, sources Sources, typmap TypeMapper) DataType {
if typmap == nil {
typmap = nilTypeMapper{}
}
valuer := TypeValuerEval{
TypeMapper: typmap,
Sources: sources,
}
typ, _ := valuer.EvalType(expr)
return typ
} | [
"func",
"EvalType",
"(",
"expr",
"Expr",
",",
"sources",
"Sources",
",",
"typmap",
"TypeMapper",
")",
"DataType",
"{",
"if",
"typmap",
"==",
"nil",
"{",
"typmap",
"=",
"nilTypeMapper",
"{",
"}",
"\n",
"}",
"\n\n",
"valuer",
":=",
"TypeValuerEval",
"{",
"TypeMapper",
":",
"typmap",
",",
"Sources",
":",
"sources",
",",
"}",
"\n",
"typ",
",",
"_",
":=",
"valuer",
".",
"EvalType",
"(",
"expr",
")",
"\n",
"return",
"typ",
"\n",
"}"
] | // EvalType evaluates the expression's type. | [
"EvalType",
"evaluates",
"the",
"expression",
"s",
"type",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L4745-L4756 |
11,044 | influxdata/influxql | ast.go | Reduce | func Reduce(expr Expr, valuer Valuer) Expr {
expr = reduce(expr, valuer)
// Unwrap parens at top level.
if expr, ok := expr.(*ParenExpr); ok {
return expr.Expr
}
return expr
} | go | func Reduce(expr Expr, valuer Valuer) Expr {
expr = reduce(expr, valuer)
// Unwrap parens at top level.
if expr, ok := expr.(*ParenExpr); ok {
return expr.Expr
}
return expr
} | [
"func",
"Reduce",
"(",
"expr",
"Expr",
",",
"valuer",
"Valuer",
")",
"Expr",
"{",
"expr",
"=",
"reduce",
"(",
"expr",
",",
"valuer",
")",
"\n\n",
"// Unwrap parens at top level.",
"if",
"expr",
",",
"ok",
":=",
"expr",
".",
"(",
"*",
"ParenExpr",
")",
";",
"ok",
"{",
"return",
"expr",
".",
"Expr",
"\n",
"}",
"\n",
"return",
"expr",
"\n",
"}"
] | // Reduce evaluates expr using the available values in valuer.
// References that don't exist in valuer are ignored. | [
"Reduce",
"evaluates",
"expr",
"using",
"the",
"available",
"values",
"in",
"valuer",
".",
"References",
"that",
"don",
"t",
"exist",
"in",
"valuer",
"are",
"ignored",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L4800-L4808 |
11,045 | influxdata/influxql | ast.go | asLiteral | func asLiteral(v interface{}) Literal {
switch v := v.(type) {
case bool:
return &BooleanLiteral{Val: v}
case time.Duration:
return &DurationLiteral{Val: v}
case float64:
return &NumberLiteral{Val: v}
case int64:
return &IntegerLiteral{Val: v}
case string:
return &StringLiteral{Val: v}
case time.Time:
return &TimeLiteral{Val: v}
default:
return &NilLiteral{}
}
} | go | func asLiteral(v interface{}) Literal {
switch v := v.(type) {
case bool:
return &BooleanLiteral{Val: v}
case time.Duration:
return &DurationLiteral{Val: v}
case float64:
return &NumberLiteral{Val: v}
case int64:
return &IntegerLiteral{Val: v}
case string:
return &StringLiteral{Val: v}
case time.Time:
return &TimeLiteral{Val: v}
default:
return &NilLiteral{}
}
} | [
"func",
"asLiteral",
"(",
"v",
"interface",
"{",
"}",
")",
"Literal",
"{",
"switch",
"v",
":=",
"v",
".",
"(",
"type",
")",
"{",
"case",
"bool",
":",
"return",
"&",
"BooleanLiteral",
"{",
"Val",
":",
"v",
"}",
"\n",
"case",
"time",
".",
"Duration",
":",
"return",
"&",
"DurationLiteral",
"{",
"Val",
":",
"v",
"}",
"\n",
"case",
"float64",
":",
"return",
"&",
"NumberLiteral",
"{",
"Val",
":",
"v",
"}",
"\n",
"case",
"int64",
":",
"return",
"&",
"IntegerLiteral",
"{",
"Val",
":",
"v",
"}",
"\n",
"case",
"string",
":",
"return",
"&",
"StringLiteral",
"{",
"Val",
":",
"v",
"}",
"\n",
"case",
"time",
".",
"Time",
":",
"return",
"&",
"TimeLiteral",
"{",
"Val",
":",
"v",
"}",
"\n",
"default",
":",
"return",
"&",
"NilLiteral",
"{",
"}",
"\n",
"}",
"\n",
"}"
] | // asLiteral takes an interface and converts it into an influxql literal. | [
"asLiteral",
"takes",
"an",
"interface",
"and",
"converts",
"it",
"into",
"an",
"influxql",
"literal",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5411-L5428 |
11,046 | influxdata/influxql | ast.go | Value | func (v *NowValuer) Value(key string) (interface{}, bool) {
if !v.Now.IsZero() && key == "now()" {
return v.Now, true
}
return nil, false
} | go | func (v *NowValuer) Value(key string) (interface{}, bool) {
if !v.Now.IsZero() && key == "now()" {
return v.Now, true
}
return nil, false
} | [
"func",
"(",
"v",
"*",
"NowValuer",
")",
"Value",
"(",
"key",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"if",
"!",
"v",
".",
"Now",
".",
"IsZero",
"(",
")",
"&&",
"key",
"==",
"\"",
"\"",
"{",
"return",
"v",
".",
"Now",
",",
"true",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] | // Value is a method that returns the value and existence flag for a given key. | [
"Value",
"is",
"a",
"method",
"that",
"returns",
"the",
"value",
"and",
"existence",
"flag",
"for",
"a",
"given",
"key",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5469-L5474 |
11,047 | influxdata/influxql | ast.go | Zone | func (v *NowValuer) Zone() *time.Location {
if v.Location != nil {
return v.Location
}
return nil
} | go | func (v *NowValuer) Zone() *time.Location {
if v.Location != nil {
return v.Location
}
return nil
} | [
"func",
"(",
"v",
"*",
"NowValuer",
")",
"Zone",
"(",
")",
"*",
"time",
".",
"Location",
"{",
"if",
"v",
".",
"Location",
"!=",
"nil",
"{",
"return",
"v",
".",
"Location",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Zone is a method that returns the time.Location. | [
"Zone",
"is",
"a",
"method",
"that",
"returns",
"the",
"time",
".",
"Location",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5485-L5490 |
11,048 | influxdata/influxql | ast.go | ContainsVarRef | func ContainsVarRef(expr Expr) bool {
var v containsVarRefVisitor
Walk(&v, expr)
return v.contains
} | go | func ContainsVarRef(expr Expr) bool {
var v containsVarRefVisitor
Walk(&v, expr)
return v.contains
} | [
"func",
"ContainsVarRef",
"(",
"expr",
"Expr",
")",
"bool",
"{",
"var",
"v",
"containsVarRefVisitor",
"\n",
"Walk",
"(",
"&",
"v",
",",
"expr",
")",
"\n",
"return",
"v",
".",
"contains",
"\n",
"}"
] | // ContainsVarRef returns true if expr is a VarRef or contains one. | [
"ContainsVarRef",
"returns",
"true",
"if",
"expr",
"is",
"a",
"VarRef",
"or",
"contains",
"one",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5535-L5539 |
11,049 | influxdata/influxql | ast.go | stringSetSlice | func stringSetSlice(m map[string]struct{}) []string {
if m == nil {
return nil
}
a := make([]string, 0, len(m))
for k := range m {
a = append(a, k)
}
sort.Strings(a)
return a
} | go | func stringSetSlice(m map[string]struct{}) []string {
if m == nil {
return nil
}
a := make([]string, 0, len(m))
for k := range m {
a = append(a, k)
}
sort.Strings(a)
return a
} | [
"func",
"stringSetSlice",
"(",
"m",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
")",
"[",
"]",
"string",
"{",
"if",
"m",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"a",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"m",
")",
")",
"\n",
"for",
"k",
":=",
"range",
"m",
"{",
"a",
"=",
"append",
"(",
"a",
",",
"k",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"a",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // stringSetSlice returns a sorted slice of keys from a string set. | [
"stringSetSlice",
"returns",
"a",
"sorted",
"slice",
"of",
"keys",
"from",
"a",
"string",
"set",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5566-L5577 |
11,050 | influxdata/influxql | ast.go | Intersect | func (t TimeRange) Intersect(other TimeRange) TimeRange {
if !other.Min.IsZero() {
if t.Min.IsZero() || other.Min.After(t.Min) {
t.Min = other.Min
}
}
if !other.Max.IsZero() {
if t.Max.IsZero() || other.Max.Before(t.Max) {
t.Max = other.Max
}
}
return t
} | go | func (t TimeRange) Intersect(other TimeRange) TimeRange {
if !other.Min.IsZero() {
if t.Min.IsZero() || other.Min.After(t.Min) {
t.Min = other.Min
}
}
if !other.Max.IsZero() {
if t.Max.IsZero() || other.Max.Before(t.Max) {
t.Max = other.Max
}
}
return t
} | [
"func",
"(",
"t",
"TimeRange",
")",
"Intersect",
"(",
"other",
"TimeRange",
")",
"TimeRange",
"{",
"if",
"!",
"other",
".",
"Min",
".",
"IsZero",
"(",
")",
"{",
"if",
"t",
".",
"Min",
".",
"IsZero",
"(",
")",
"||",
"other",
".",
"Min",
".",
"After",
"(",
"t",
".",
"Min",
")",
"{",
"t",
".",
"Min",
"=",
"other",
".",
"Min",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"other",
".",
"Max",
".",
"IsZero",
"(",
")",
"{",
"if",
"t",
".",
"Max",
".",
"IsZero",
"(",
")",
"||",
"other",
".",
"Max",
".",
"Before",
"(",
"t",
".",
"Max",
")",
"{",
"t",
".",
"Max",
"=",
"other",
".",
"Max",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"t",
"\n",
"}"
] | // Intersect joins this TimeRange with another TimeRange. | [
"Intersect",
"joins",
"this",
"TimeRange",
"with",
"another",
"TimeRange",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5585-L5597 |
11,051 | influxdata/influxql | ast.go | IsZero | func (t TimeRange) IsZero() bool {
return t.Min.IsZero() && t.Max.IsZero()
} | go | func (t TimeRange) IsZero() bool {
return t.Min.IsZero() && t.Max.IsZero()
} | [
"func",
"(",
"t",
"TimeRange",
")",
"IsZero",
"(",
")",
"bool",
"{",
"return",
"t",
".",
"Min",
".",
"IsZero",
"(",
")",
"&&",
"t",
".",
"Max",
".",
"IsZero",
"(",
")",
"\n",
"}"
] | // IsZero is true if the min and max of the time range are zero. | [
"IsZero",
"is",
"true",
"if",
"the",
"min",
"and",
"max",
"of",
"the",
"time",
"range",
"are",
"zero",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5600-L5602 |
11,052 | influxdata/influxql | ast.go | MinTime | func (t TimeRange) MinTime() time.Time {
if t.Min.IsZero() {
return minTime
}
return t.Min
} | go | func (t TimeRange) MinTime() time.Time {
if t.Min.IsZero() {
return minTime
}
return t.Min
} | [
"func",
"(",
"t",
"TimeRange",
")",
"MinTime",
"(",
")",
"time",
".",
"Time",
"{",
"if",
"t",
".",
"Min",
".",
"IsZero",
"(",
")",
"{",
"return",
"minTime",
"\n",
"}",
"\n",
"return",
"t",
".",
"Min",
"\n",
"}"
] | // MinTime returns the minimum time of the TimeRange.
// If the minimum time is zero, this returns the minimum possible time. | [
"MinTime",
"returns",
"the",
"minimum",
"time",
"of",
"the",
"TimeRange",
".",
"If",
"the",
"minimum",
"time",
"is",
"zero",
"this",
"returns",
"the",
"minimum",
"possible",
"time",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5610-L5615 |
11,053 | influxdata/influxql | ast.go | MaxTime | func (t TimeRange) MaxTime() time.Time {
if t.Max.IsZero() {
return maxTime
}
return t.Max
} | go | func (t TimeRange) MaxTime() time.Time {
if t.Max.IsZero() {
return maxTime
}
return t.Max
} | [
"func",
"(",
"t",
"TimeRange",
")",
"MaxTime",
"(",
")",
"time",
".",
"Time",
"{",
"if",
"t",
".",
"Max",
".",
"IsZero",
"(",
")",
"{",
"return",
"maxTime",
"\n",
"}",
"\n",
"return",
"t",
".",
"Max",
"\n",
"}"
] | // MaxTime returns the maximum time of the TimeRange.
// If the maximum time is zero, this returns the maximum possible time. | [
"MaxTime",
"returns",
"the",
"maximum",
"time",
"of",
"the",
"TimeRange",
".",
"If",
"the",
"maximum",
"time",
"is",
"zero",
"this",
"returns",
"the",
"maximum",
"possible",
"time",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5619-L5624 |
11,054 | influxdata/influxql | ast.go | MinTimeNano | func (t TimeRange) MinTimeNano() int64 {
if t.Min.IsZero() {
return MinTime
}
return t.Min.UnixNano()
} | go | func (t TimeRange) MinTimeNano() int64 {
if t.Min.IsZero() {
return MinTime
}
return t.Min.UnixNano()
} | [
"func",
"(",
"t",
"TimeRange",
")",
"MinTimeNano",
"(",
")",
"int64",
"{",
"if",
"t",
".",
"Min",
".",
"IsZero",
"(",
")",
"{",
"return",
"MinTime",
"\n",
"}",
"\n",
"return",
"t",
".",
"Min",
".",
"UnixNano",
"(",
")",
"\n",
"}"
] | // MinTimeNano returns the minimum time in nanoseconds since the epoch.
// If the minimum time is zero, this returns the minimum possible time. | [
"MinTimeNano",
"returns",
"the",
"minimum",
"time",
"in",
"nanoseconds",
"since",
"the",
"epoch",
".",
"If",
"the",
"minimum",
"time",
"is",
"zero",
"this",
"returns",
"the",
"minimum",
"possible",
"time",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5628-L5633 |
11,055 | influxdata/influxql | ast.go | MaxTimeNano | func (t TimeRange) MaxTimeNano() int64 {
if t.Max.IsZero() {
return MaxTime
}
return t.Max.UnixNano()
} | go | func (t TimeRange) MaxTimeNano() int64 {
if t.Max.IsZero() {
return MaxTime
}
return t.Max.UnixNano()
} | [
"func",
"(",
"t",
"TimeRange",
")",
"MaxTimeNano",
"(",
")",
"int64",
"{",
"if",
"t",
".",
"Max",
".",
"IsZero",
"(",
")",
"{",
"return",
"MaxTime",
"\n",
"}",
"\n",
"return",
"t",
".",
"Max",
".",
"UnixNano",
"(",
")",
"\n",
"}"
] | // MaxTimeNano returns the maximum time in nanoseconds since the epoch.
// If the maximum time is zero, this returns the maximum possible time. | [
"MaxTimeNano",
"returns",
"the",
"maximum",
"time",
"in",
"nanoseconds",
"since",
"the",
"epoch",
".",
"If",
"the",
"maximum",
"time",
"is",
"zero",
"this",
"returns",
"the",
"maximum",
"possible",
"time",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5637-L5642 |
11,056 | influxdata/influxql | ast.go | ConditionExpr | func ConditionExpr(cond Expr, valuer Valuer) (Expr, TimeRange, error) {
expr, tr, err := conditionExpr(cond, valuer)
// Remove top level parentheses
if e, ok := expr.(*ParenExpr); ok {
expr = e.Expr
}
if e, ok := expr.(*BooleanLiteral); ok && e.Val {
// If the condition is true, return nil instead to indicate there
// is no condition.
expr = nil
}
return expr, tr, err
} | go | func ConditionExpr(cond Expr, valuer Valuer) (Expr, TimeRange, error) {
expr, tr, err := conditionExpr(cond, valuer)
// Remove top level parentheses
if e, ok := expr.(*ParenExpr); ok {
expr = e.Expr
}
if e, ok := expr.(*BooleanLiteral); ok && e.Val {
// If the condition is true, return nil instead to indicate there
// is no condition.
expr = nil
}
return expr, tr, err
} | [
"func",
"ConditionExpr",
"(",
"cond",
"Expr",
",",
"valuer",
"Valuer",
")",
"(",
"Expr",
",",
"TimeRange",
",",
"error",
")",
"{",
"expr",
",",
"tr",
",",
"err",
":=",
"conditionExpr",
"(",
"cond",
",",
"valuer",
")",
"\n\n",
"// Remove top level parentheses",
"if",
"e",
",",
"ok",
":=",
"expr",
".",
"(",
"*",
"ParenExpr",
")",
";",
"ok",
"{",
"expr",
"=",
"e",
".",
"Expr",
"\n",
"}",
"\n\n",
"if",
"e",
",",
"ok",
":=",
"expr",
".",
"(",
"*",
"BooleanLiteral",
")",
";",
"ok",
"&&",
"e",
".",
"Val",
"{",
"// If the condition is true, return nil instead to indicate there",
"// is no condition.",
"expr",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"expr",
",",
"tr",
",",
"err",
"\n",
"}"
] | // ConditionExpr extracts the time range and the condition from an expression.
// We only support simple time ranges that are constrained with AND and are not nested.
// This throws an error when we encounter a time condition that is combined with OR
// to prevent returning unexpected results that we do not support. | [
"ConditionExpr",
"extracts",
"the",
"time",
"range",
"and",
"the",
"condition",
"from",
"an",
"expression",
".",
"We",
"only",
"support",
"simple",
"time",
"ranges",
"that",
"are",
"constrained",
"with",
"AND",
"and",
"are",
"not",
"nested",
".",
"This",
"throws",
"an",
"error",
"when",
"we",
"encounter",
"a",
"time",
"condition",
"that",
"is",
"combined",
"with",
"OR",
"to",
"prevent",
"returning",
"unexpected",
"results",
"that",
"we",
"do",
"not",
"support",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5648-L5662 |
11,057 | influxdata/influxql | ast.go | getTimeRange | func getTimeRange(op Token, rhs Expr, valuer Valuer) (TimeRange, error) {
// If literal looks like a date time then parse it as a time literal.
if strlit, ok := rhs.(*StringLiteral); ok {
if strlit.IsTimeLiteral() {
var loc *time.Location
if valuer, ok := valuer.(ZoneValuer); ok {
loc = valuer.Zone()
}
t, err := strlit.ToTimeLiteral(loc)
if err != nil {
return TimeRange{}, err
}
rhs = t
}
}
// Evaluate the RHS to replace "now()" with the current time.
rhs = Reduce(rhs, valuer)
var value time.Time
switch lit := rhs.(type) {
case *TimeLiteral:
if lit.Val.After(time.Unix(0, MaxTime)) {
return TimeRange{}, fmt.Errorf("time %s overflows time literal", lit.Val.Format(time.RFC3339))
} else if lit.Val.Before(time.Unix(0, MinTime+1)) {
// The minimum allowable time literal is one greater than the minimum time because the minimum time
// is a sentinel value only used internally.
return TimeRange{}, fmt.Errorf("time %s underflows time literal", lit.Val.Format(time.RFC3339))
}
value = lit.Val
case *DurationLiteral:
value = time.Unix(0, int64(lit.Val)).UTC()
case *NumberLiteral:
value = time.Unix(0, int64(lit.Val)).UTC()
case *IntegerLiteral:
value = time.Unix(0, lit.Val).UTC()
default:
return TimeRange{}, fmt.Errorf("invalid operation: time and %T are not compatible", lit)
}
timeRange := TimeRange{}
switch op {
case GT:
timeRange.Min = value.Add(time.Nanosecond)
case GTE:
timeRange.Min = value
case LT:
timeRange.Max = value.Add(-time.Nanosecond)
case LTE:
timeRange.Max = value
case EQ:
timeRange.Min, timeRange.Max = value, value
default:
return TimeRange{}, fmt.Errorf("invalid time comparison operator: %s", op)
}
return timeRange, nil
} | go | func getTimeRange(op Token, rhs Expr, valuer Valuer) (TimeRange, error) {
// If literal looks like a date time then parse it as a time literal.
if strlit, ok := rhs.(*StringLiteral); ok {
if strlit.IsTimeLiteral() {
var loc *time.Location
if valuer, ok := valuer.(ZoneValuer); ok {
loc = valuer.Zone()
}
t, err := strlit.ToTimeLiteral(loc)
if err != nil {
return TimeRange{}, err
}
rhs = t
}
}
// Evaluate the RHS to replace "now()" with the current time.
rhs = Reduce(rhs, valuer)
var value time.Time
switch lit := rhs.(type) {
case *TimeLiteral:
if lit.Val.After(time.Unix(0, MaxTime)) {
return TimeRange{}, fmt.Errorf("time %s overflows time literal", lit.Val.Format(time.RFC3339))
} else if lit.Val.Before(time.Unix(0, MinTime+1)) {
// The minimum allowable time literal is one greater than the minimum time because the minimum time
// is a sentinel value only used internally.
return TimeRange{}, fmt.Errorf("time %s underflows time literal", lit.Val.Format(time.RFC3339))
}
value = lit.Val
case *DurationLiteral:
value = time.Unix(0, int64(lit.Val)).UTC()
case *NumberLiteral:
value = time.Unix(0, int64(lit.Val)).UTC()
case *IntegerLiteral:
value = time.Unix(0, lit.Val).UTC()
default:
return TimeRange{}, fmt.Errorf("invalid operation: time and %T are not compatible", lit)
}
timeRange := TimeRange{}
switch op {
case GT:
timeRange.Min = value.Add(time.Nanosecond)
case GTE:
timeRange.Min = value
case LT:
timeRange.Max = value.Add(-time.Nanosecond)
case LTE:
timeRange.Max = value
case EQ:
timeRange.Min, timeRange.Max = value, value
default:
return TimeRange{}, fmt.Errorf("invalid time comparison operator: %s", op)
}
return timeRange, nil
} | [
"func",
"getTimeRange",
"(",
"op",
"Token",
",",
"rhs",
"Expr",
",",
"valuer",
"Valuer",
")",
"(",
"TimeRange",
",",
"error",
")",
"{",
"// If literal looks like a date time then parse it as a time literal.",
"if",
"strlit",
",",
"ok",
":=",
"rhs",
".",
"(",
"*",
"StringLiteral",
")",
";",
"ok",
"{",
"if",
"strlit",
".",
"IsTimeLiteral",
"(",
")",
"{",
"var",
"loc",
"*",
"time",
".",
"Location",
"\n",
"if",
"valuer",
",",
"ok",
":=",
"valuer",
".",
"(",
"ZoneValuer",
")",
";",
"ok",
"{",
"loc",
"=",
"valuer",
".",
"Zone",
"(",
")",
"\n",
"}",
"\n",
"t",
",",
"err",
":=",
"strlit",
".",
"ToTimeLiteral",
"(",
"loc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"TimeRange",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"rhs",
"=",
"t",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Evaluate the RHS to replace \"now()\" with the current time.",
"rhs",
"=",
"Reduce",
"(",
"rhs",
",",
"valuer",
")",
"\n\n",
"var",
"value",
"time",
".",
"Time",
"\n",
"switch",
"lit",
":=",
"rhs",
".",
"(",
"type",
")",
"{",
"case",
"*",
"TimeLiteral",
":",
"if",
"lit",
".",
"Val",
".",
"After",
"(",
"time",
".",
"Unix",
"(",
"0",
",",
"MaxTime",
")",
")",
"{",
"return",
"TimeRange",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"lit",
".",
"Val",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"}",
"else",
"if",
"lit",
".",
"Val",
".",
"Before",
"(",
"time",
".",
"Unix",
"(",
"0",
",",
"MinTime",
"+",
"1",
")",
")",
"{",
"// The minimum allowable time literal is one greater than the minimum time because the minimum time",
"// is a sentinel value only used internally.",
"return",
"TimeRange",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"lit",
".",
"Val",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"}",
"\n",
"value",
"=",
"lit",
".",
"Val",
"\n",
"case",
"*",
"DurationLiteral",
":",
"value",
"=",
"time",
".",
"Unix",
"(",
"0",
",",
"int64",
"(",
"lit",
".",
"Val",
")",
")",
".",
"UTC",
"(",
")",
"\n",
"case",
"*",
"NumberLiteral",
":",
"value",
"=",
"time",
".",
"Unix",
"(",
"0",
",",
"int64",
"(",
"lit",
".",
"Val",
")",
")",
".",
"UTC",
"(",
")",
"\n",
"case",
"*",
"IntegerLiteral",
":",
"value",
"=",
"time",
".",
"Unix",
"(",
"0",
",",
"lit",
".",
"Val",
")",
".",
"UTC",
"(",
")",
"\n",
"default",
":",
"return",
"TimeRange",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"lit",
")",
"\n",
"}",
"\n\n",
"timeRange",
":=",
"TimeRange",
"{",
"}",
"\n",
"switch",
"op",
"{",
"case",
"GT",
":",
"timeRange",
".",
"Min",
"=",
"value",
".",
"Add",
"(",
"time",
".",
"Nanosecond",
")",
"\n",
"case",
"GTE",
":",
"timeRange",
".",
"Min",
"=",
"value",
"\n",
"case",
"LT",
":",
"timeRange",
".",
"Max",
"=",
"value",
".",
"Add",
"(",
"-",
"time",
".",
"Nanosecond",
")",
"\n",
"case",
"LTE",
":",
"timeRange",
".",
"Max",
"=",
"value",
"\n",
"case",
"EQ",
":",
"timeRange",
".",
"Min",
",",
"timeRange",
".",
"Max",
"=",
"value",
",",
"value",
"\n",
"default",
":",
"return",
"TimeRange",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"op",
")",
"\n",
"}",
"\n",
"return",
"timeRange",
",",
"nil",
"\n",
"}"
] | // getTimeRange returns the time range associated with this comparison.
// op is the operation that is used for comparison and rhs is the right hand side
// of the expression. The left hand side is always assumed to be "time". | [
"getTimeRange",
"returns",
"the",
"time",
"range",
"associated",
"with",
"this",
"comparison",
".",
"op",
"is",
"the",
"operation",
"that",
"is",
"used",
"for",
"comparison",
"and",
"rhs",
"is",
"the",
"right",
"hand",
"side",
"of",
"the",
"expression",
".",
"The",
"left",
"hand",
"side",
"is",
"always",
"assumed",
"to",
"be",
"time",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/ast.go#L5739-L5795 |
11,058 | influxdata/influxql | parser.go | ParseStatement | func ParseStatement(s string) (Statement, error) {
return NewParser(strings.NewReader(s)).ParseStatement()
} | go | func ParseStatement(s string) (Statement, error) {
return NewParser(strings.NewReader(s)).ParseStatement()
} | [
"func",
"ParseStatement",
"(",
"s",
"string",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"return",
"NewParser",
"(",
"strings",
".",
"NewReader",
"(",
"s",
")",
")",
".",
"ParseStatement",
"(",
")",
"\n",
"}"
] | // ParseStatement parses a statement string and returns its AST representation. | [
"ParseStatement",
"parses",
"a",
"statement",
"string",
"and",
"returns",
"its",
"AST",
"representation",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L43-L45 |
11,059 | influxdata/influxql | parser.go | MustParseStatement | func MustParseStatement(s string) Statement {
stmt, err := ParseStatement(s)
if err != nil {
panic(err.Error())
}
return stmt
} | go | func MustParseStatement(s string) Statement {
stmt, err := ParseStatement(s)
if err != nil {
panic(err.Error())
}
return stmt
} | [
"func",
"MustParseStatement",
"(",
"s",
"string",
")",
"Statement",
"{",
"stmt",
",",
"err",
":=",
"ParseStatement",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"stmt",
"\n",
"}"
] | // MustParseStatement parses a statement string and returns its AST. Panic on error. | [
"MustParseStatement",
"parses",
"a",
"statement",
"string",
"and",
"returns",
"its",
"AST",
".",
"Panic",
"on",
"error",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L48-L54 |
11,060 | influxdata/influxql | parser.go | MustParseExpr | func MustParseExpr(s string) Expr {
expr, err := ParseExpr(s)
if err != nil {
panic(err.Error())
}
return expr
} | go | func MustParseExpr(s string) Expr {
expr, err := ParseExpr(s)
if err != nil {
panic(err.Error())
}
return expr
} | [
"func",
"MustParseExpr",
"(",
"s",
"string",
")",
"Expr",
"{",
"expr",
",",
"err",
":=",
"ParseExpr",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"expr",
"\n",
"}"
] | // MustParseExpr parses an expression string and returns its AST. Panic on error. | [
"MustParseExpr",
"parses",
"an",
"expression",
"string",
"and",
"returns",
"its",
"AST",
".",
"Panic",
"on",
"error",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L60-L66 |
11,061 | influxdata/influxql | parser.go | ParseQuery | func (p *Parser) ParseQuery() (*Query, error) {
var statements Statements
semi := true
for {
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok == EOF {
return &Query{Statements: statements}, nil
} else if tok == SEMICOLON {
semi = true
} else {
if !semi {
return nil, newParseError(tokstr(tok, lit), []string{";"}, pos)
}
p.Unscan()
s, err := p.ParseStatement()
if err != nil {
return nil, err
}
statements = append(statements, s)
semi = false
}
}
} | go | func (p *Parser) ParseQuery() (*Query, error) {
var statements Statements
semi := true
for {
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok == EOF {
return &Query{Statements: statements}, nil
} else if tok == SEMICOLON {
semi = true
} else {
if !semi {
return nil, newParseError(tokstr(tok, lit), []string{";"}, pos)
}
p.Unscan()
s, err := p.ParseStatement()
if err != nil {
return nil, err
}
statements = append(statements, s)
semi = false
}
}
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"ParseQuery",
"(",
")",
"(",
"*",
"Query",
",",
"error",
")",
"{",
"var",
"statements",
"Statements",
"\n",
"semi",
":=",
"true",
"\n\n",
"for",
"{",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"EOF",
"{",
"return",
"&",
"Query",
"{",
"Statements",
":",
"statements",
"}",
",",
"nil",
"\n",
"}",
"else",
"if",
"tok",
"==",
"SEMICOLON",
"{",
"semi",
"=",
"true",
"\n",
"}",
"else",
"{",
"if",
"!",
"semi",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"p",
".",
"Unscan",
"(",
")",
"\n",
"s",
",",
"err",
":=",
"p",
".",
"ParseStatement",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"statements",
"=",
"append",
"(",
"statements",
",",
"s",
")",
"\n",
"semi",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // ParseQuery parses an InfluxQL string and returns a Query AST object. | [
"ParseQuery",
"parses",
"an",
"InfluxQL",
"string",
"and",
"returns",
"a",
"Query",
"AST",
"object",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L69-L91 |
11,062 | influxdata/influxql | parser.go | parseSetPasswordUserStatement | func (p *Parser) parseSetPasswordUserStatement() (*SetPasswordUserStatement, error) {
stmt := &SetPasswordUserStatement{}
// Parse username
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Consume the required = token.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != EQ {
return nil, newParseError(tokstr(tok, lit), []string{"="}, pos)
}
// Parse new user's password
if ident, err = p.parseString(); err != nil {
return nil, err
}
stmt.Password = ident
return stmt, nil
} | go | func (p *Parser) parseSetPasswordUserStatement() (*SetPasswordUserStatement, error) {
stmt := &SetPasswordUserStatement{}
// Parse username
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Consume the required = token.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != EQ {
return nil, newParseError(tokstr(tok, lit), []string{"="}, pos)
}
// Parse new user's password
if ident, err = p.parseString(); err != nil {
return nil, err
}
stmt.Password = ident
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseSetPasswordUserStatement",
"(",
")",
"(",
"*",
"SetPasswordUserStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"SetPasswordUserStatement",
"{",
"}",
"\n\n",
"// Parse username",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"ident",
"\n\n",
"// Consume the required = token.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"EQ",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Parse new user's password",
"if",
"ident",
",",
"err",
"=",
"p",
".",
"parseString",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Password",
"=",
"ident",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseSetPasswordUserStatement parses a string and returns a set statement.
// This function assumes the SET token has already been consumed. | [
"parseSetPasswordUserStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"set",
"statement",
".",
"This",
"function",
"assumes",
"the",
"SET",
"token",
"has",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L100-L123 |
11,063 | influxdata/influxql | parser.go | parseKillQueryStatement | func (p *Parser) parseKillQueryStatement() (*KillQueryStatement, error) {
qid, err := p.ParseUInt64()
if err != nil {
return nil, err
}
var host string
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
host, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
return &KillQueryStatement{QueryID: qid, Host: host}, nil
} | go | func (p *Parser) parseKillQueryStatement() (*KillQueryStatement, error) {
qid, err := p.ParseUInt64()
if err != nil {
return nil, err
}
var host string
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
host, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
return &KillQueryStatement{QueryID: qid, Host: host}, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseKillQueryStatement",
"(",
")",
"(",
"*",
"KillQueryStatement",
",",
"error",
")",
"{",
"qid",
",",
"err",
":=",
"p",
".",
"ParseUInt64",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"host",
"string",
"\n",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"host",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n",
"return",
"&",
"KillQueryStatement",
"{",
"QueryID",
":",
"qid",
",",
"Host",
":",
"host",
"}",
",",
"nil",
"\n",
"}"
] | // parseKillQueryStatement parses a string and returns a kill statement.
// This function assumes the KILL token has already been consumed. | [
"parseKillQueryStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"kill",
"statement",
".",
"This",
"function",
"assumes",
"the",
"KILL",
"token",
"has",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L127-L143 |
11,064 | influxdata/influxql | parser.go | parseCreateSubscriptionStatement | func (p *Parser) parseCreateSubscriptionStatement() (*CreateSubscriptionStatement, error) {
stmt := &CreateSubscriptionStatement{}
// Read the id of the subscription to create.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Expect an "ON" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Read the name of the database.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.Database = ident
if tok, pos, lit := p.Scan(); tok != DOT {
return nil, newParseError(tokstr(tok, lit), []string{"."}, pos)
}
// Read the name of the retention policy.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.RetentionPolicy = ident
// Expect a "DESTINATIONS" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != DESTINATIONS {
return nil, newParseError(tokstr(tok, lit), []string{"DESTINATIONS"}, pos)
}
// Expect one of "ANY ALL" keywords.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok == ALL || tok == ANY {
stmt.Mode = tokens[tok]
} else {
return nil, newParseError(tokstr(tok, lit), []string{"ALL", "ANY"}, pos)
}
// Read list of destinations.
var destinations []string
if destinations, err = p.parseStringList(); err != nil {
return nil, err
}
stmt.Destinations = destinations
return stmt, nil
} | go | func (p *Parser) parseCreateSubscriptionStatement() (*CreateSubscriptionStatement, error) {
stmt := &CreateSubscriptionStatement{}
// Read the id of the subscription to create.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Expect an "ON" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Read the name of the database.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.Database = ident
if tok, pos, lit := p.Scan(); tok != DOT {
return nil, newParseError(tokstr(tok, lit), []string{"."}, pos)
}
// Read the name of the retention policy.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.RetentionPolicy = ident
// Expect a "DESTINATIONS" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != DESTINATIONS {
return nil, newParseError(tokstr(tok, lit), []string{"DESTINATIONS"}, pos)
}
// Expect one of "ANY ALL" keywords.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok == ALL || tok == ANY {
stmt.Mode = tokens[tok]
} else {
return nil, newParseError(tokstr(tok, lit), []string{"ALL", "ANY"}, pos)
}
// Read list of destinations.
var destinations []string
if destinations, err = p.parseStringList(); err != nil {
return nil, err
}
stmt.Destinations = destinations
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseCreateSubscriptionStatement",
"(",
")",
"(",
"*",
"CreateSubscriptionStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"CreateSubscriptionStatement",
"{",
"}",
"\n\n",
"// Read the id of the subscription to create.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"ident",
"\n\n",
"// Expect an \"ON\" keyword.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"ON",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Read the name of the database.",
"if",
"ident",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Database",
"=",
"ident",
"\n\n",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"Scan",
"(",
")",
";",
"tok",
"!=",
"DOT",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Read the name of the retention policy.",
"if",
"ident",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"RetentionPolicy",
"=",
"ident",
"\n\n",
"// Expect a \"DESTINATIONS\" keyword.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"DESTINATIONS",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Expect one of \"ANY ALL\" keywords.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ALL",
"||",
"tok",
"==",
"ANY",
"{",
"stmt",
".",
"Mode",
"=",
"tokens",
"[",
"tok",
"]",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Read list of destinations.",
"var",
"destinations",
"[",
"]",
"string",
"\n",
"if",
"destinations",
",",
"err",
"=",
"p",
".",
"parseStringList",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Destinations",
"=",
"destinations",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseCreateSubscriptionStatement parses a string and returns a CreateSubscriptionStatement.
// This function assumes the "CREATE SUBSCRIPTION" tokens have already been consumed. | [
"parseCreateSubscriptionStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"CreateSubscriptionStatement",
".",
"This",
"function",
"assumes",
"the",
"CREATE",
"SUBSCRIPTION",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L147-L198 |
11,065 | influxdata/influxql | parser.go | parseCreateRetentionPolicyStatement | func (p *Parser) parseCreateRetentionPolicyStatement() (*CreateRetentionPolicyStatement, error) {
stmt := &CreateRetentionPolicyStatement{}
// Parse the retention policy name.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Consume the required ON token.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Parse the database name.
ident, err = p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Database = ident
// Parse required DURATION token.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != DURATION {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION"}, pos)
}
// Parse duration value
d, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.Duration = d
// Parse required REPLICATION token.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != REPLICATION {
return nil, newParseError(tokstr(tok, lit), []string{"REPLICATION"}, pos)
}
// Parse replication value.
n, err := p.ParseInt(1, math.MaxInt32)
if err != nil {
return nil, err
}
stmt.Replication = n
// Parse optional SHARD token.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == SHARD {
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != DURATION {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION"}, pos)
}
// Check to see if they used the INF keyword
tok, pos, _ := p.ScanIgnoreWhitespace()
if tok == INF {
return nil, &ParseError{
Message: "invalid duration INF for shard duration",
Pos: pos,
}
}
p.Unscan()
d, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.ShardGroupDuration = d
} else {
p.Unscan()
}
// Parse optional DEFAULT token.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == DEFAULT {
stmt.Default = true
} else {
p.Unscan()
}
return stmt, nil
} | go | func (p *Parser) parseCreateRetentionPolicyStatement() (*CreateRetentionPolicyStatement, error) {
stmt := &CreateRetentionPolicyStatement{}
// Parse the retention policy name.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Consume the required ON token.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Parse the database name.
ident, err = p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Database = ident
// Parse required DURATION token.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != DURATION {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION"}, pos)
}
// Parse duration value
d, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.Duration = d
// Parse required REPLICATION token.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != REPLICATION {
return nil, newParseError(tokstr(tok, lit), []string{"REPLICATION"}, pos)
}
// Parse replication value.
n, err := p.ParseInt(1, math.MaxInt32)
if err != nil {
return nil, err
}
stmt.Replication = n
// Parse optional SHARD token.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == SHARD {
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != DURATION {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION"}, pos)
}
// Check to see if they used the INF keyword
tok, pos, _ := p.ScanIgnoreWhitespace()
if tok == INF {
return nil, &ParseError{
Message: "invalid duration INF for shard duration",
Pos: pos,
}
}
p.Unscan()
d, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.ShardGroupDuration = d
} else {
p.Unscan()
}
// Parse optional DEFAULT token.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == DEFAULT {
stmt.Default = true
} else {
p.Unscan()
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseCreateRetentionPolicyStatement",
"(",
")",
"(",
"*",
"CreateRetentionPolicyStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"CreateRetentionPolicyStatement",
"{",
"}",
"\n\n",
"// Parse the retention policy name.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"ident",
"\n\n",
"// Consume the required ON token.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"ON",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Parse the database name.",
"ident",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Database",
"=",
"ident",
"\n\n",
"// Parse required DURATION token.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"DURATION",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Parse duration value",
"d",
",",
"err",
":=",
"p",
".",
"ParseDuration",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Duration",
"=",
"d",
"\n\n",
"// Parse required REPLICATION token.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"REPLICATION",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Parse replication value.",
"n",
",",
"err",
":=",
"p",
".",
"ParseInt",
"(",
"1",
",",
"math",
".",
"MaxInt32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Replication",
"=",
"n",
"\n\n",
"// Parse optional SHARD token.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"SHARD",
"{",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"DURATION",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Check to see if they used the INF keyword",
"tok",
",",
"pos",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"==",
"INF",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Message",
":",
"\"",
"\"",
",",
"Pos",
":",
"pos",
",",
"}",
"\n",
"}",
"\n",
"p",
".",
"Unscan",
"(",
")",
"\n\n",
"d",
",",
"err",
":=",
"p",
".",
"ParseDuration",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"ShardGroupDuration",
"=",
"d",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional DEFAULT token.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"DEFAULT",
"{",
"stmt",
".",
"Default",
"=",
"true",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseCreateRetentionPolicyStatement parses a string and returns a create retention policy statement.
// This function assumes the CREATE RETENTION POLICY tokens have already been consumed. | [
"parseCreateRetentionPolicyStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"create",
"retention",
"policy",
"statement",
".",
"This",
"function",
"assumes",
"the",
"CREATE",
"RETENTION",
"POLICY",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L202-L281 |
11,066 | influxdata/influxql | parser.go | parseAlterRetentionPolicyStatement | func (p *Parser) parseAlterRetentionPolicyStatement() (*AlterRetentionPolicyStatement, error) {
stmt := &AlterRetentionPolicyStatement{}
// Parse the retention policy name.
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == DEFAULT {
stmt.Name = "default"
} else if tok == IDENT {
stmt.Name = lit
} else {
return nil, newParseError(tokstr(tok, lit), []string{"identifier"}, pos)
}
// Consume the required ON token.
if tok, pos, lit = p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Parse the database name.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Database = ident
// Loop through option tokens (DURATION, REPLICATION, SHARD DURATION, DEFAULT, etc.).
found := make(map[Token]struct{})
Loop:
for {
tok, pos, lit := p.ScanIgnoreWhitespace()
if _, ok := found[tok]; ok {
return nil, &ParseError{
Message: fmt.Sprintf("found duplicate %s option", tok),
Pos: pos,
}
}
switch tok {
case DURATION:
d, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.Duration = &d
case REPLICATION:
n, err := p.ParseInt(1, math.MaxInt32)
if err != nil {
return nil, err
}
stmt.Replication = &n
case SHARD:
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == DURATION {
// Check to see if they used the INF keyword
tok, pos, _ := p.ScanIgnoreWhitespace()
if tok == INF {
return nil, &ParseError{
Message: "invalid duration INF for shard duration",
Pos: pos,
}
}
p.Unscan()
d, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.ShardGroupDuration = &d
} else {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION"}, pos)
}
case DEFAULT:
stmt.Default = true
default:
if len(found) == 0 {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION", "REPLICATION", "SHARD", "DEFAULT"}, pos)
}
p.Unscan()
break Loop
}
found[tok] = struct{}{}
}
return stmt, nil
} | go | func (p *Parser) parseAlterRetentionPolicyStatement() (*AlterRetentionPolicyStatement, error) {
stmt := &AlterRetentionPolicyStatement{}
// Parse the retention policy name.
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == DEFAULT {
stmt.Name = "default"
} else if tok == IDENT {
stmt.Name = lit
} else {
return nil, newParseError(tokstr(tok, lit), []string{"identifier"}, pos)
}
// Consume the required ON token.
if tok, pos, lit = p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Parse the database name.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Database = ident
// Loop through option tokens (DURATION, REPLICATION, SHARD DURATION, DEFAULT, etc.).
found := make(map[Token]struct{})
Loop:
for {
tok, pos, lit := p.ScanIgnoreWhitespace()
if _, ok := found[tok]; ok {
return nil, &ParseError{
Message: fmt.Sprintf("found duplicate %s option", tok),
Pos: pos,
}
}
switch tok {
case DURATION:
d, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.Duration = &d
case REPLICATION:
n, err := p.ParseInt(1, math.MaxInt32)
if err != nil {
return nil, err
}
stmt.Replication = &n
case SHARD:
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == DURATION {
// Check to see if they used the INF keyword
tok, pos, _ := p.ScanIgnoreWhitespace()
if tok == INF {
return nil, &ParseError{
Message: "invalid duration INF for shard duration",
Pos: pos,
}
}
p.Unscan()
d, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.ShardGroupDuration = &d
} else {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION"}, pos)
}
case DEFAULT:
stmt.Default = true
default:
if len(found) == 0 {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION", "REPLICATION", "SHARD", "DEFAULT"}, pos)
}
p.Unscan()
break Loop
}
found[tok] = struct{}{}
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseAlterRetentionPolicyStatement",
"(",
")",
"(",
"*",
"AlterRetentionPolicyStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"AlterRetentionPolicyStatement",
"{",
"}",
"\n\n",
"// Parse the retention policy name.",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"==",
"DEFAULT",
"{",
"stmt",
".",
"Name",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"if",
"tok",
"==",
"IDENT",
"{",
"stmt",
".",
"Name",
"=",
"lit",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Consume the required ON token.",
"if",
"tok",
",",
"pos",
",",
"lit",
"=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"ON",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Parse the database name.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Database",
"=",
"ident",
"\n\n",
"// Loop through option tokens (DURATION, REPLICATION, SHARD DURATION, DEFAULT, etc.).",
"found",
":=",
"make",
"(",
"map",
"[",
"Token",
"]",
"struct",
"{",
"}",
")",
"\n",
"Loop",
":",
"for",
"{",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"found",
"[",
"tok",
"]",
";",
"ok",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tok",
")",
",",
"Pos",
":",
"pos",
",",
"}",
"\n",
"}",
"\n\n",
"switch",
"tok",
"{",
"case",
"DURATION",
":",
"d",
",",
"err",
":=",
"p",
".",
"ParseDuration",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Duration",
"=",
"&",
"d",
"\n",
"case",
"REPLICATION",
":",
"n",
",",
"err",
":=",
"p",
".",
"ParseInt",
"(",
"1",
",",
"math",
".",
"MaxInt32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Replication",
"=",
"&",
"n",
"\n",
"case",
"SHARD",
":",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"==",
"DURATION",
"{",
"// Check to see if they used the INF keyword",
"tok",
",",
"pos",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"==",
"INF",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Message",
":",
"\"",
"\"",
",",
"Pos",
":",
"pos",
",",
"}",
"\n",
"}",
"\n",
"p",
".",
"Unscan",
"(",
")",
"\n\n",
"d",
",",
"err",
":=",
"p",
".",
"ParseDuration",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"ShardGroupDuration",
"=",
"&",
"d",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"case",
"DEFAULT",
":",
"stmt",
".",
"Default",
"=",
"true",
"\n",
"default",
":",
"if",
"len",
"(",
"found",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"p",
".",
"Unscan",
"(",
")",
"\n",
"break",
"Loop",
"\n",
"}",
"\n",
"found",
"[",
"tok",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseAlterRetentionPolicyStatement parses a string and returns an alter retention policy statement.
// This function assumes the ALTER RETENTION POLICY tokens have already been consumed. | [
"parseAlterRetentionPolicyStatement",
"parses",
"a",
"string",
"and",
"returns",
"an",
"alter",
"retention",
"policy",
"statement",
".",
"This",
"function",
"assumes",
"the",
"ALTER",
"RETENTION",
"POLICY",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L285-L369 |
11,067 | influxdata/influxql | parser.go | ParseUInt64 | func (p *Parser) ParseUInt64() (uint64, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != INTEGER {
return 0, newParseError(tokstr(tok, lit), []string{"integer"}, pos)
}
// Convert string to unsigned 64-bit integer
n, err := strconv.ParseUint(lit, 10, 64)
if err != nil {
return 0, &ParseError{Message: err.Error(), Pos: pos}
}
return uint64(n), nil
} | go | func (p *Parser) ParseUInt64() (uint64, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != INTEGER {
return 0, newParseError(tokstr(tok, lit), []string{"integer"}, pos)
}
// Convert string to unsigned 64-bit integer
n, err := strconv.ParseUint(lit, 10, 64)
if err != nil {
return 0, &ParseError{Message: err.Error(), Pos: pos}
}
return uint64(n), nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"ParseUInt64",
"(",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"!=",
"INTEGER",
"{",
"return",
"0",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Convert string to unsigned 64-bit integer",
"n",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"lit",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"&",
"ParseError",
"{",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"Pos",
":",
"pos",
"}",
"\n",
"}",
"\n\n",
"return",
"uint64",
"(",
"n",
")",
",",
"nil",
"\n",
"}"
] | // ParseUInt64 parses a string and returns a 64-bit unsigned integer literal. | [
"ParseUInt64",
"parses",
"a",
"string",
"and",
"returns",
"a",
"64",
"-",
"bit",
"unsigned",
"integer",
"literal",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L394-L407 |
11,068 | influxdata/influxql | parser.go | ParseDuration | func (p *Parser) ParseDuration() (time.Duration, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != DURATIONVAL && tok != INF {
return 0, newParseError(tokstr(tok, lit), []string{"duration"}, pos)
}
if tok == INF {
return 0, nil
}
d, err := ParseDuration(lit)
if err != nil {
return 0, &ParseError{Message: err.Error(), Pos: pos}
}
return d, nil
} | go | func (p *Parser) ParseDuration() (time.Duration, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != DURATIONVAL && tok != INF {
return 0, newParseError(tokstr(tok, lit), []string{"duration"}, pos)
}
if tok == INF {
return 0, nil
}
d, err := ParseDuration(lit)
if err != nil {
return 0, &ParseError{Message: err.Error(), Pos: pos}
}
return d, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"ParseDuration",
"(",
")",
"(",
"time",
".",
"Duration",
",",
"error",
")",
"{",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"!=",
"DURATIONVAL",
"&&",
"tok",
"!=",
"INF",
"{",
"return",
"0",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"if",
"tok",
"==",
"INF",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n\n",
"d",
",",
"err",
":=",
"ParseDuration",
"(",
"lit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"&",
"ParseError",
"{",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"Pos",
":",
"pos",
"}",
"\n",
"}",
"\n\n",
"return",
"d",
",",
"nil",
"\n",
"}"
] | // ParseDuration parses a string and returns a duration literal.
// This function assumes the DURATION token has already been consumed. | [
"ParseDuration",
"parses",
"a",
"string",
"and",
"returns",
"a",
"duration",
"literal",
".",
"This",
"function",
"assumes",
"the",
"DURATION",
"token",
"has",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L411-L427 |
11,069 | influxdata/influxql | parser.go | ParseIdent | func (p *Parser) ParseIdent() (string, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != IDENT {
return "", newParseError(tokstr(tok, lit), []string{"identifier"}, pos)
}
return lit, nil
} | go | func (p *Parser) ParseIdent() (string, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != IDENT {
return "", newParseError(tokstr(tok, lit), []string{"identifier"}, pos)
}
return lit, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"ParseIdent",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"!=",
"IDENT",
"{",
"return",
"\"",
"\"",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"return",
"lit",
",",
"nil",
"\n",
"}"
] | // ParseIdent parses an identifier. | [
"ParseIdent",
"parses",
"an",
"identifier",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L430-L436 |
11,070 | influxdata/influxql | parser.go | ParseIdentList | func (p *Parser) ParseIdentList() ([]string, error) {
// Parse first (required) identifier.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
idents := []string{ident}
// Parse remaining (optional) identifiers.
for {
if tok, _, _ := p.ScanIgnoreWhitespace(); tok != COMMA {
p.Unscan()
return idents, nil
}
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
idents = append(idents, ident)
}
} | go | func (p *Parser) ParseIdentList() ([]string, error) {
// Parse first (required) identifier.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
idents := []string{ident}
// Parse remaining (optional) identifiers.
for {
if tok, _, _ := p.ScanIgnoreWhitespace(); tok != COMMA {
p.Unscan()
return idents, nil
}
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
idents = append(idents, ident)
}
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"ParseIdentList",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"// Parse first (required) identifier.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"idents",
":=",
"[",
"]",
"string",
"{",
"ident",
"}",
"\n\n",
"// Parse remaining (optional) identifiers.",
"for",
"{",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"COMMA",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"return",
"idents",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"ident",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"idents",
"=",
"append",
"(",
"idents",
",",
"ident",
")",
"\n",
"}",
"\n",
"}"
] | // ParseIdentList parses a comma delimited list of identifiers. | [
"ParseIdentList",
"parses",
"a",
"comma",
"delimited",
"list",
"of",
"identifiers",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L439-L460 |
11,071 | influxdata/influxql | parser.go | parseString | func (p *Parser) parseString() (string, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != STRING {
return "", newParseError(tokstr(tok, lit), []string{"string"}, pos)
}
return lit, nil
} | go | func (p *Parser) parseString() (string, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != STRING {
return "", newParseError(tokstr(tok, lit), []string{"string"}, pos)
}
return lit, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseString",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"!=",
"STRING",
"{",
"return",
"\"",
"\"",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"return",
"lit",
",",
"nil",
"\n",
"}"
] | // parseString parses a string. | [
"parseString",
"parses",
"a",
"string",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L508-L514 |
11,072 | influxdata/influxql | parser.go | parseStringList | func (p *Parser) parseStringList() ([]string, error) {
// Parse first (required) string.
str, err := p.parseString()
if err != nil {
return nil, err
}
strs := []string{str}
// Parse remaining (optional) strings.
for {
if tok, _, _ := p.ScanIgnoreWhitespace(); tok != COMMA {
p.Unscan()
return strs, nil
}
if str, err = p.parseString(); err != nil {
return nil, err
}
strs = append(strs, str)
}
} | go | func (p *Parser) parseStringList() ([]string, error) {
// Parse first (required) string.
str, err := p.parseString()
if err != nil {
return nil, err
}
strs := []string{str}
// Parse remaining (optional) strings.
for {
if tok, _, _ := p.ScanIgnoreWhitespace(); tok != COMMA {
p.Unscan()
return strs, nil
}
if str, err = p.parseString(); err != nil {
return nil, err
}
strs = append(strs, str)
}
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseStringList",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"// Parse first (required) string.",
"str",
",",
"err",
":=",
"p",
".",
"parseString",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"strs",
":=",
"[",
"]",
"string",
"{",
"str",
"}",
"\n\n",
"// Parse remaining (optional) strings.",
"for",
"{",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"COMMA",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"return",
"strs",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"str",
",",
"err",
"=",
"p",
".",
"parseString",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"strs",
"=",
"append",
"(",
"strs",
",",
"str",
")",
"\n",
"}",
"\n",
"}"
] | // parseStringList parses a list of strings separated by commas. | [
"parseStringList",
"parses",
"a",
"list",
"of",
"strings",
"separated",
"by",
"commas",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L517-L538 |
11,073 | influxdata/influxql | parser.go | parseRevokeStatement | func (p *Parser) parseRevokeStatement() (Statement, error) {
// Parse the privilege to be revoked.
priv, err := p.parsePrivilege()
if err != nil {
return nil, err
}
// Check for ON or FROM clauses.
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == ON {
stmt, err := p.parseRevokeOnStatement()
if err != nil {
return nil, err
}
stmt.Privilege = priv
return stmt, nil
} else if tok == FROM {
// Admin privilege is only revoked on ALL PRIVILEGES.
if priv != AllPrivileges {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
return p.parseRevokeAdminStatement()
}
// Only ON or FROM clauses are allowed after privilege.
if priv == AllPrivileges {
return nil, newParseError(tokstr(tok, lit), []string{"ON", "FROM"}, pos)
}
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
} | go | func (p *Parser) parseRevokeStatement() (Statement, error) {
// Parse the privilege to be revoked.
priv, err := p.parsePrivilege()
if err != nil {
return nil, err
}
// Check for ON or FROM clauses.
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == ON {
stmt, err := p.parseRevokeOnStatement()
if err != nil {
return nil, err
}
stmt.Privilege = priv
return stmt, nil
} else if tok == FROM {
// Admin privilege is only revoked on ALL PRIVILEGES.
if priv != AllPrivileges {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
return p.parseRevokeAdminStatement()
}
// Only ON or FROM clauses are allowed after privilege.
if priv == AllPrivileges {
return nil, newParseError(tokstr(tok, lit), []string{"ON", "FROM"}, pos)
}
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseRevokeStatement",
"(",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"// Parse the privilege to be revoked.",
"priv",
",",
"err",
":=",
"p",
".",
"parsePrivilege",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Check for ON or FROM clauses.",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"==",
"ON",
"{",
"stmt",
",",
"err",
":=",
"p",
".",
"parseRevokeOnStatement",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Privilege",
"=",
"priv",
"\n",
"return",
"stmt",
",",
"nil",
"\n",
"}",
"else",
"if",
"tok",
"==",
"FROM",
"{",
"// Admin privilege is only revoked on ALL PRIVILEGES.",
"if",
"priv",
"!=",
"AllPrivileges",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"return",
"p",
".",
"parseRevokeAdminStatement",
"(",
")",
"\n",
"}",
"\n\n",
"// Only ON or FROM clauses are allowed after privilege.",
"if",
"priv",
"==",
"AllPrivileges",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}"
] | // parseRevokeStatement parses a string and returns a revoke statement.
// This function assumes the REVOKE token has already been consumed. | [
"parseRevokeStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"revoke",
"statement",
".",
"This",
"function",
"assumes",
"the",
"REVOKE",
"token",
"has",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L542-L571 |
11,074 | influxdata/influxql | parser.go | parseGrantStatement | func (p *Parser) parseGrantStatement() (Statement, error) {
// Parse the privilege to be granted.
priv, err := p.parsePrivilege()
if err != nil {
return nil, err
}
// Check for ON or TO clauses.
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == ON {
stmt, err := p.parseGrantOnStatement()
if err != nil {
return nil, err
}
stmt.Privilege = priv
return stmt, nil
} else if tok == TO {
// Admin privilege is only granted on ALL PRIVILEGES.
if priv != AllPrivileges {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
return p.parseGrantAdminStatement()
}
// Only ON or TO clauses are allowed after privilege.
if priv == AllPrivileges {
return nil, newParseError(tokstr(tok, lit), []string{"ON", "TO"}, pos)
}
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
} | go | func (p *Parser) parseGrantStatement() (Statement, error) {
// Parse the privilege to be granted.
priv, err := p.parsePrivilege()
if err != nil {
return nil, err
}
// Check for ON or TO clauses.
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == ON {
stmt, err := p.parseGrantOnStatement()
if err != nil {
return nil, err
}
stmt.Privilege = priv
return stmt, nil
} else if tok == TO {
// Admin privilege is only granted on ALL PRIVILEGES.
if priv != AllPrivileges {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
return p.parseGrantAdminStatement()
}
// Only ON or TO clauses are allowed after privilege.
if priv == AllPrivileges {
return nil, newParseError(tokstr(tok, lit), []string{"ON", "TO"}, pos)
}
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseGrantStatement",
"(",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"// Parse the privilege to be granted.",
"priv",
",",
"err",
":=",
"p",
".",
"parsePrivilege",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Check for ON or TO clauses.",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"==",
"ON",
"{",
"stmt",
",",
"err",
":=",
"p",
".",
"parseGrantOnStatement",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Privilege",
"=",
"priv",
"\n",
"return",
"stmt",
",",
"nil",
"\n",
"}",
"else",
"if",
"tok",
"==",
"TO",
"{",
"// Admin privilege is only granted on ALL PRIVILEGES.",
"if",
"priv",
"!=",
"AllPrivileges",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"return",
"p",
".",
"parseGrantAdminStatement",
"(",
")",
"\n",
"}",
"\n\n",
"// Only ON or TO clauses are allowed after privilege.",
"if",
"priv",
"==",
"AllPrivileges",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}"
] | // parseGrantStatement parses a string and returns a grant statement.
// This function assumes the GRANT token has already been consumed. | [
"parseGrantStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"grant",
"statement",
".",
"This",
"function",
"assumes",
"the",
"GRANT",
"token",
"has",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L621-L650 |
11,075 | influxdata/influxql | parser.go | parsePrivilege | func (p *Parser) parsePrivilege() (Privilege, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
switch tok {
case READ:
return ReadPrivilege, nil
case WRITE:
return WritePrivilege, nil
case ALL:
// Consume optional PRIVILEGES token
tok, pos, lit = p.ScanIgnoreWhitespace()
if tok != PRIVILEGES {
p.Unscan()
}
return AllPrivileges, nil
}
return 0, newParseError(tokstr(tok, lit), []string{"READ", "WRITE", "ALL [PRIVILEGES]"}, pos)
} | go | func (p *Parser) parsePrivilege() (Privilege, error) {
tok, pos, lit := p.ScanIgnoreWhitespace()
switch tok {
case READ:
return ReadPrivilege, nil
case WRITE:
return WritePrivilege, nil
case ALL:
// Consume optional PRIVILEGES token
tok, pos, lit = p.ScanIgnoreWhitespace()
if tok != PRIVILEGES {
p.Unscan()
}
return AllPrivileges, nil
}
return 0, newParseError(tokstr(tok, lit), []string{"READ", "WRITE", "ALL [PRIVILEGES]"}, pos)
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parsePrivilege",
"(",
")",
"(",
"Privilege",
",",
"error",
")",
"{",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"switch",
"tok",
"{",
"case",
"READ",
":",
"return",
"ReadPrivilege",
",",
"nil",
"\n",
"case",
"WRITE",
":",
"return",
"WritePrivilege",
",",
"nil",
"\n",
"case",
"ALL",
":",
"// Consume optional PRIVILEGES token",
"tok",
",",
"pos",
",",
"lit",
"=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"!=",
"PRIVILEGES",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n",
"return",
"AllPrivileges",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}"
] | // parsePrivilege parses a string and returns a Privilege. | [
"parsePrivilege",
"parses",
"a",
"string",
"and",
"returns",
"a",
"Privilege",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L699-L715 |
11,076 | influxdata/influxql | parser.go | parseSelectStatement | func (p *Parser) parseSelectStatement(tr targetRequirement) (*SelectStatement, error) {
stmt := &SelectStatement{}
var err error
// Parse fields: "FIELD+".
if stmt.Fields, err = p.parseFields(); err != nil {
return nil, err
}
// Parse target: "INTO"
if stmt.Target, err = p.parseTarget(tr); err != nil {
return nil, err
}
// Parse source: "FROM".
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != FROM {
return nil, newParseError(tokstr(tok, lit), []string{"FROM"}, pos)
}
if stmt.Sources, err = p.parseSources(true); err != nil {
return nil, err
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse dimensions: "GROUP BY DIMENSION+".
if stmt.Dimensions, err = p.parseDimensions(); err != nil {
return nil, err
}
// Parse fill options: "fill(<option>)"
if stmt.Fill, stmt.FillValue, err = p.parseFill(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
// Parse series limit: "SLIMIT <n>".
if stmt.SLimit, err = p.ParseOptionalTokenAndInt(SLIMIT); err != nil {
return nil, err
}
// Parse series offset: "SOFFSET <n>".
if stmt.SOffset, err = p.ParseOptionalTokenAndInt(SOFFSET); err != nil {
return nil, err
}
// Parse timezone: "TZ(<timezone>)".
if stmt.Location, err = p.parseLocation(); err != nil {
return nil, err
}
// Set if the query is a raw data query or one with an aggregate
stmt.IsRawQuery = true
WalkFunc(stmt.Fields, func(n Node) {
if _, ok := n.(*Call); ok {
stmt.IsRawQuery = false
}
})
return stmt, nil
} | go | func (p *Parser) parseSelectStatement(tr targetRequirement) (*SelectStatement, error) {
stmt := &SelectStatement{}
var err error
// Parse fields: "FIELD+".
if stmt.Fields, err = p.parseFields(); err != nil {
return nil, err
}
// Parse target: "INTO"
if stmt.Target, err = p.parseTarget(tr); err != nil {
return nil, err
}
// Parse source: "FROM".
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != FROM {
return nil, newParseError(tokstr(tok, lit), []string{"FROM"}, pos)
}
if stmt.Sources, err = p.parseSources(true); err != nil {
return nil, err
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse dimensions: "GROUP BY DIMENSION+".
if stmt.Dimensions, err = p.parseDimensions(); err != nil {
return nil, err
}
// Parse fill options: "fill(<option>)"
if stmt.Fill, stmt.FillValue, err = p.parseFill(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
// Parse series limit: "SLIMIT <n>".
if stmt.SLimit, err = p.ParseOptionalTokenAndInt(SLIMIT); err != nil {
return nil, err
}
// Parse series offset: "SOFFSET <n>".
if stmt.SOffset, err = p.ParseOptionalTokenAndInt(SOFFSET); err != nil {
return nil, err
}
// Parse timezone: "TZ(<timezone>)".
if stmt.Location, err = p.parseLocation(); err != nil {
return nil, err
}
// Set if the query is a raw data query or one with an aggregate
stmt.IsRawQuery = true
WalkFunc(stmt.Fields, func(n Node) {
if _, ok := n.(*Call); ok {
stmt.IsRawQuery = false
}
})
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseSelectStatement",
"(",
"tr",
"targetRequirement",
")",
"(",
"*",
"SelectStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"SelectStatement",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n\n",
"// Parse fields: \"FIELD+\".",
"if",
"stmt",
".",
"Fields",
",",
"err",
"=",
"p",
".",
"parseFields",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse target: \"INTO\"",
"if",
"stmt",
".",
"Target",
",",
"err",
"=",
"p",
".",
"parseTarget",
"(",
"tr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse source: \"FROM\".",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"FROM",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse dimensions: \"GROUP BY DIMENSION+\".",
"if",
"stmt",
".",
"Dimensions",
",",
"err",
"=",
"p",
".",
"parseDimensions",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse fill options: \"fill(<option>)\"",
"if",
"stmt",
".",
"Fill",
",",
"stmt",
".",
"FillValue",
",",
"err",
"=",
"p",
".",
"parseFill",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse sort: \"ORDER BY FIELD+\".",
"if",
"stmt",
".",
"SortFields",
",",
"err",
"=",
"p",
".",
"parseOrderBy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit: \"LIMIT <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse offset: \"OFFSET <n>\".",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse series limit: \"SLIMIT <n>\".",
"if",
"stmt",
".",
"SLimit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"SLIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse series offset: \"SOFFSET <n>\".",
"if",
"stmt",
".",
"SOffset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"SOFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse timezone: \"TZ(<timezone>)\".",
"if",
"stmt",
".",
"Location",
",",
"err",
"=",
"p",
".",
"parseLocation",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Set if the query is a raw data query or one with an aggregate",
"stmt",
".",
"IsRawQuery",
"=",
"true",
"\n",
"WalkFunc",
"(",
"stmt",
".",
"Fields",
",",
"func",
"(",
"n",
"Node",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"n",
".",
"(",
"*",
"Call",
")",
";",
"ok",
"{",
"stmt",
".",
"IsRawQuery",
"=",
"false",
"\n",
"}",
"\n",
"}",
")",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseSelectStatement parses a select string and returns a Statement AST object.
// This function assumes the SELECT token has already been consumed. | [
"parseSelectStatement",
"parses",
"a",
"select",
"string",
"and",
"returns",
"a",
"Statement",
"AST",
"object",
".",
"This",
"function",
"assumes",
"the",
"SELECT",
"token",
"has",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L719-L795 |
11,077 | influxdata/influxql | parser.go | parseTarget | func (p *Parser) parseTarget(tr targetRequirement) (*Target, error) {
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != INTO {
if tr == targetRequired {
return nil, newParseError(tokstr(tok, lit), []string{"INTO"}, pos)
}
p.Unscan()
return nil, nil
}
// db, rp, and / or measurement
idents, err := p.parseSegmentedIdents()
if err != nil {
return nil, err
}
if len(idents) < 3 {
// Check for source measurement reference.
if ch := p.peekRune(); ch == ':' {
if err := p.parseTokens([]Token{COLON, MEASUREMENT}); err != nil {
return nil, err
}
// Append empty measurement name.
idents = append(idents, "")
}
}
t := &Target{Measurement: &Measurement{IsTarget: true}}
switch len(idents) {
case 1:
t.Measurement.Name = idents[0]
case 2:
t.Measurement.RetentionPolicy = idents[0]
t.Measurement.Name = idents[1]
case 3:
t.Measurement.Database = idents[0]
t.Measurement.RetentionPolicy = idents[1]
t.Measurement.Name = idents[2]
}
return t, nil
} | go | func (p *Parser) parseTarget(tr targetRequirement) (*Target, error) {
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != INTO {
if tr == targetRequired {
return nil, newParseError(tokstr(tok, lit), []string{"INTO"}, pos)
}
p.Unscan()
return nil, nil
}
// db, rp, and / or measurement
idents, err := p.parseSegmentedIdents()
if err != nil {
return nil, err
}
if len(idents) < 3 {
// Check for source measurement reference.
if ch := p.peekRune(); ch == ':' {
if err := p.parseTokens([]Token{COLON, MEASUREMENT}); err != nil {
return nil, err
}
// Append empty measurement name.
idents = append(idents, "")
}
}
t := &Target{Measurement: &Measurement{IsTarget: true}}
switch len(idents) {
case 1:
t.Measurement.Name = idents[0]
case 2:
t.Measurement.RetentionPolicy = idents[0]
t.Measurement.Name = idents[1]
case 3:
t.Measurement.Database = idents[0]
t.Measurement.RetentionPolicy = idents[1]
t.Measurement.Name = idents[2]
}
return t, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseTarget",
"(",
"tr",
"targetRequirement",
")",
"(",
"*",
"Target",
",",
"error",
")",
"{",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"INTO",
"{",
"if",
"tr",
"==",
"targetRequired",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"p",
".",
"Unscan",
"(",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"// db, rp, and / or measurement",
"idents",
",",
"err",
":=",
"p",
".",
"parseSegmentedIdents",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"idents",
")",
"<",
"3",
"{",
"// Check for source measurement reference.",
"if",
"ch",
":=",
"p",
".",
"peekRune",
"(",
")",
";",
"ch",
"==",
"':'",
"{",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"COLON",
",",
"MEASUREMENT",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// Append empty measurement name.",
"idents",
"=",
"append",
"(",
"idents",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"t",
":=",
"&",
"Target",
"{",
"Measurement",
":",
"&",
"Measurement",
"{",
"IsTarget",
":",
"true",
"}",
"}",
"\n\n",
"switch",
"len",
"(",
"idents",
")",
"{",
"case",
"1",
":",
"t",
".",
"Measurement",
".",
"Name",
"=",
"idents",
"[",
"0",
"]",
"\n",
"case",
"2",
":",
"t",
".",
"Measurement",
".",
"RetentionPolicy",
"=",
"idents",
"[",
"0",
"]",
"\n",
"t",
".",
"Measurement",
".",
"Name",
"=",
"idents",
"[",
"1",
"]",
"\n",
"case",
"3",
":",
"t",
".",
"Measurement",
".",
"Database",
"=",
"idents",
"[",
"0",
"]",
"\n",
"t",
".",
"Measurement",
".",
"RetentionPolicy",
"=",
"idents",
"[",
"1",
"]",
"\n",
"t",
".",
"Measurement",
".",
"Name",
"=",
"idents",
"[",
"2",
"]",
"\n",
"}",
"\n\n",
"return",
"t",
",",
"nil",
"\n",
"}"
] | // parseTarget parses a string and returns a Target. | [
"parseTarget",
"parses",
"a",
"string",
"and",
"returns",
"a",
"Target",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L807-L848 |
11,078 | influxdata/influxql | parser.go | parseDeleteStatement | func (p *Parser) parseDeleteStatement() (Statement, error) {
stmt := &DeleteSeriesStatement{}
var err error
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == FROM {
// Parse source.
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
var err error
WalkFunc(stmt.Sources, func(n Node) {
if t, ok := n.(*Measurement); ok {
// Don't allow database or retention policy in from clause for delete
// statement. They apply to the selected database across all retention
// policies.
if t.Database != "" {
err = &ParseError{Message: "database not supported"}
}
if t.RetentionPolicy != "" {
err = &ParseError{Message: "retention policy not supported"}
}
}
})
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// If they didn't provide a FROM or a WHERE, this query is invalid
if stmt.Condition == nil && stmt.Sources == nil {
return nil, newParseError(tokstr(tok, lit), []string{"FROM", "WHERE"}, pos)
}
return stmt, nil
} | go | func (p *Parser) parseDeleteStatement() (Statement, error) {
stmt := &DeleteSeriesStatement{}
var err error
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == FROM {
// Parse source.
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
var err error
WalkFunc(stmt.Sources, func(n Node) {
if t, ok := n.(*Measurement); ok {
// Don't allow database or retention policy in from clause for delete
// statement. They apply to the selected database across all retention
// policies.
if t.Database != "" {
err = &ParseError{Message: "database not supported"}
}
if t.RetentionPolicy != "" {
err = &ParseError{Message: "retention policy not supported"}
}
}
})
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// If they didn't provide a FROM or a WHERE, this query is invalid
if stmt.Condition == nil && stmt.Sources == nil {
return nil, newParseError(tokstr(tok, lit), []string{"FROM", "WHERE"}, pos)
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseDeleteStatement",
"(",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"DeleteSeriesStatement",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n\n",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n\n",
"if",
"tok",
"==",
"FROM",
"{",
"// Parse source.",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"WalkFunc",
"(",
"stmt",
".",
"Sources",
",",
"func",
"(",
"n",
"Node",
")",
"{",
"if",
"t",
",",
"ok",
":=",
"n",
".",
"(",
"*",
"Measurement",
")",
";",
"ok",
"{",
"// Don't allow database or retention policy in from clause for delete",
"// statement. They apply to the selected database across all retention",
"// policies.",
"if",
"t",
".",
"Database",
"!=",
"\"",
"\"",
"{",
"err",
"=",
"&",
"ParseError",
"{",
"Message",
":",
"\"",
"\"",
"}",
"\n",
"}",
"\n",
"if",
"t",
".",
"RetentionPolicy",
"!=",
"\"",
"\"",
"{",
"err",
"=",
"&",
"ParseError",
"{",
"Message",
":",
"\"",
"\"",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// If they didn't provide a FROM or a WHERE, this query is invalid",
"if",
"stmt",
".",
"Condition",
"==",
"nil",
"&&",
"stmt",
".",
"Sources",
"==",
"nil",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseDeleteStatement parses a string and returns a delete statement.
// This function assumes the DELETE token has already been consumed. | [
"parseDeleteStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"delete",
"statement",
".",
"This",
"function",
"assumes",
"the",
"DELETE",
"token",
"has",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L852-L897 |
11,079 | influxdata/influxql | parser.go | parseShowSeriesStatement | func (p *Parser) parseShowSeriesStatement() (Statement, error) {
var exactCardinality bool
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == EXACT {
exactCardinality = true
} else {
p.Unscan()
}
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == CARDINALITY {
return p.parseShowSeriesCardinalityStatement(exactCardinality)
}
p.Unscan()
// Handle SHOW SERIES statments.
stmt := &ShowSeriesStatement{}
var err error
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional FROM.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseShowSeriesStatement() (Statement, error) {
var exactCardinality bool
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == EXACT {
exactCardinality = true
} else {
p.Unscan()
}
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == CARDINALITY {
return p.parseShowSeriesCardinalityStatement(exactCardinality)
}
p.Unscan()
// Handle SHOW SERIES statments.
stmt := &ShowSeriesStatement{}
var err error
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional FROM.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowSeriesStatement",
"(",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"var",
"exactCardinality",
"bool",
"\n",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"EXACT",
"{",
"exactCardinality",
"=",
"true",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"CARDINALITY",
"{",
"return",
"p",
".",
"parseShowSeriesCardinalityStatement",
"(",
"exactCardinality",
")",
"\n",
"}",
"\n",
"p",
".",
"Unscan",
"(",
")",
"\n\n",
"// Handle SHOW SERIES statments.",
"stmt",
":=",
"&",
"ShowSeriesStatement",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n\n",
"// Parse optional ON clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"// Parse the database.",
"stmt",
".",
"Database",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional FROM.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"FROM",
"{",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse sort: \"ORDER BY FIELD+\".",
"if",
"stmt",
".",
"SortFields",
",",
"err",
"=",
"p",
".",
"parseOrderBy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit: \"LIMIT <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse offset: \"OFFSET <n>\".",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseShowSeriesStatement parses a string and returns a Statement.
// This function assumes the "SHOW SERIES" tokens have already been consumed. | [
"parseShowSeriesStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"Statement",
".",
"This",
"function",
"assumes",
"the",
"SHOW",
"SERIES",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L901-L960 |
11,080 | influxdata/influxql | parser.go | parseShowSeriesCardinalityStatement | func (p *Parser) parseShowSeriesCardinalityStatement(exact bool) (Statement, error) {
var err error
stmt := &ShowSeriesCardinalityStatement{Exact: exact}
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
if stmt.Database, err = p.ParseIdent(); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional FROM.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse dimensions: "GROUP BY DIMENSION+".
if stmt.Dimensions, err = p.parseDimensions(); err != nil {
return nil, err
}
// Parse limit & offset: "LIMIT <n>", "OFFSET <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
} else if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseShowSeriesCardinalityStatement(exact bool) (Statement, error) {
var err error
stmt := &ShowSeriesCardinalityStatement{Exact: exact}
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
if stmt.Database, err = p.ParseIdent(); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional FROM.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse dimensions: "GROUP BY DIMENSION+".
if stmt.Dimensions, err = p.parseDimensions(); err != nil {
return nil, err
}
// Parse limit & offset: "LIMIT <n>", "OFFSET <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
} else if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowSeriesCardinalityStatement",
"(",
"exact",
"bool",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"stmt",
":=",
"&",
"ShowSeriesCardinalityStatement",
"{",
"Exact",
":",
"exact",
"}",
"\n\n",
"// Parse optional ON clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"if",
"stmt",
".",
"Database",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional FROM.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"FROM",
"{",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse dimensions: \"GROUP BY DIMENSION+\".",
"if",
"stmt",
".",
"Dimensions",
",",
"err",
"=",
"p",
".",
"parseDimensions",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit & offset: \"LIMIT <n>\", \"OFFSET <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // This function assumes the "SHOW SERIES EXACT CARDINALITY" or the
// "SHOW SERIES CARDINALITY" tokens have already been consumed. | [
"This",
"function",
"assumes",
"the",
"SHOW",
"SERIES",
"EXACT",
"CARDINALITY",
"or",
"the",
"SHOW",
"SERIES",
"CARDINALITY",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L964-L1004 |
11,081 | influxdata/influxql | parser.go | parseShowMeasurementsStatement | func (p *Parser) parseShowMeasurementsStatement() (*ShowMeasurementsStatement, error) {
stmt := &ShowMeasurementsStatement{}
var err error
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional WITH clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == WITH {
// Parse required MEASUREMENT token.
if err := p.parseTokens([]Token{MEASUREMENT}); err != nil {
return nil, err
}
// Parse required operator: = or =~.
tok, pos, lit := p.ScanIgnoreWhitespace()
switch tok {
case EQ, EQREGEX:
// Parse required source (measurement name or regex).
if stmt.Source, err = p.parseSource(false); err != nil {
return nil, err
}
default:
return nil, newParseError(tokstr(tok, lit), []string{"=", "=~"}, pos)
}
} else {
// Not a WITH clause so put the token back.
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseShowMeasurementsStatement() (*ShowMeasurementsStatement, error) {
stmt := &ShowMeasurementsStatement{}
var err error
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional WITH clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == WITH {
// Parse required MEASUREMENT token.
if err := p.parseTokens([]Token{MEASUREMENT}); err != nil {
return nil, err
}
// Parse required operator: = or =~.
tok, pos, lit := p.ScanIgnoreWhitespace()
switch tok {
case EQ, EQREGEX:
// Parse required source (measurement name or regex).
if stmt.Source, err = p.parseSource(false); err != nil {
return nil, err
}
default:
return nil, newParseError(tokstr(tok, lit), []string{"=", "=~"}, pos)
}
} else {
// Not a WITH clause so put the token back.
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowMeasurementsStatement",
"(",
")",
"(",
"*",
"ShowMeasurementsStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"ShowMeasurementsStatement",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n\n",
"// Parse optional ON clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"// Parse the database.",
"stmt",
".",
"Database",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional WITH clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"WITH",
"{",
"// Parse required MEASUREMENT token.",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"MEASUREMENT",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse required operator: = or =~.",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"switch",
"tok",
"{",
"case",
"EQ",
",",
"EQREGEX",
":",
"// Parse required source (measurement name or regex).",
"if",
"stmt",
".",
"Source",
",",
"err",
"=",
"p",
".",
"parseSource",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"default",
":",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Not a WITH clause so put the token back.",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse sort: \"ORDER BY FIELD+\".",
"if",
"stmt",
".",
"SortFields",
",",
"err",
"=",
"p",
".",
"parseOrderBy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit: \"LIMIT <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse offset: \"OFFSET <n>\".",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseShowMeasurementsStatement parses a string and returns a Statement.
// This function assumes the "SHOW MEASUREMENTS" tokens have already been consumed. | [
"parseShowMeasurementsStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"Statement",
".",
"This",
"function",
"assumes",
"the",
"SHOW",
"MEASUREMENTS",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1058-L1117 |
11,082 | influxdata/influxql | parser.go | parseShowRetentionPoliciesStatement | func (p *Parser) parseShowRetentionPoliciesStatement() (*ShowRetentionPoliciesStatement, error) {
stmt := &ShowRetentionPoliciesStatement{}
// Expect an "ON" keyword.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Database = ident
} else {
p.Unscan()
}
return stmt, nil
} | go | func (p *Parser) parseShowRetentionPoliciesStatement() (*ShowRetentionPoliciesStatement, error) {
stmt := &ShowRetentionPoliciesStatement{}
// Expect an "ON" keyword.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Database = ident
} else {
p.Unscan()
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowRetentionPoliciesStatement",
"(",
")",
"(",
"*",
"ShowRetentionPoliciesStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"ShowRetentionPoliciesStatement",
"{",
"}",
"\n\n",
"// Expect an \"ON\" keyword.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"// Parse the database.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Database",
"=",
"ident",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseShowRetentionPoliciesStatement parses a string and returns a ShowRetentionPoliciesStatement.
// This function assumes the "SHOW RETENTION POLICIES" tokens have been consumed. | [
"parseShowRetentionPoliciesStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"ShowRetentionPoliciesStatement",
".",
"This",
"function",
"assumes",
"the",
"SHOW",
"RETENTION",
"POLICIES",
"tokens",
"have",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1127-L1143 |
11,083 | influxdata/influxql | parser.go | parseShowTagKeysStatement | func (p *Parser) parseShowTagKeysStatement() (*ShowTagKeysStatement, error) {
stmt := &ShowTagKeysStatement{}
var err error
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional source.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
// Parse series limit: "SLIMIT <n>".
if stmt.SLimit, err = p.ParseOptionalTokenAndInt(SLIMIT); err != nil {
return nil, err
}
// Parse series offset: "SOFFSET <n>".
if stmt.SOffset, err = p.ParseOptionalTokenAndInt(SOFFSET); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseShowTagKeysStatement() (*ShowTagKeysStatement, error) {
stmt := &ShowTagKeysStatement{}
var err error
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional source.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
// Parse series limit: "SLIMIT <n>".
if stmt.SLimit, err = p.ParseOptionalTokenAndInt(SLIMIT); err != nil {
return nil, err
}
// Parse series offset: "SOFFSET <n>".
if stmt.SOffset, err = p.ParseOptionalTokenAndInt(SOFFSET); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowTagKeysStatement",
"(",
")",
"(",
"*",
"ShowTagKeysStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"ShowTagKeysStatement",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n\n",
"// Parse optional ON clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"// Parse the database.",
"stmt",
".",
"Database",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional source.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"FROM",
"{",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse sort: \"ORDER BY FIELD+\".",
"if",
"stmt",
".",
"SortFields",
",",
"err",
"=",
"p",
".",
"parseOrderBy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit: \"LIMIT <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse offset: \"OFFSET <n>\".",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse series limit: \"SLIMIT <n>\".",
"if",
"stmt",
".",
"SLimit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"SLIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse series offset: \"SOFFSET <n>\".",
"if",
"stmt",
".",
"SOffset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"SOFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseShowTagKeysStatement parses a string and returns a Statement.
// This function assumes the "SHOW TAG KEYS" tokens have already been consumed. | [
"parseShowTagKeysStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"Statement",
".",
"This",
"function",
"assumes",
"the",
"SHOW",
"TAG",
"KEYS",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1204-L1259 |
11,084 | influxdata/influxql | parser.go | parseShowTagValuesStatement | func (p *Parser) parseShowTagValuesStatement() (Statement, error) {
stmt := &ShowTagValuesStatement{}
var err error
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == EXACT {
return p.parseShowTagValuesCardinalityStatement(true)
} else if tok == CARDINALITY {
return p.parseShowTagValuesCardinalityStatement(false)
}
p.Unscan()
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional source.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse required WITH KEY.
if stmt.Op, stmt.TagKeyExpr, err = p.parseTagKeyExpr(); err != nil {
return nil, err
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseShowTagValuesStatement() (Statement, error) {
stmt := &ShowTagValuesStatement{}
var err error
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == EXACT {
return p.parseShowTagValuesCardinalityStatement(true)
} else if tok == CARDINALITY {
return p.parseShowTagValuesCardinalityStatement(false)
}
p.Unscan()
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional source.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse required WITH KEY.
if stmt.Op, stmt.TagKeyExpr, err = p.parseTagKeyExpr(); err != nil {
return nil, err
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowTagValuesStatement",
"(",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"ShowTagValuesStatement",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"EXACT",
"{",
"return",
"p",
".",
"parseShowTagValuesCardinalityStatement",
"(",
"true",
")",
"\n",
"}",
"else",
"if",
"tok",
"==",
"CARDINALITY",
"{",
"return",
"p",
".",
"parseShowTagValuesCardinalityStatement",
"(",
"false",
")",
"\n",
"}",
"\n",
"p",
".",
"Unscan",
"(",
")",
"\n\n",
"// Parse optional ON clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"// Parse the database.",
"stmt",
".",
"Database",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional source.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"FROM",
"{",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse required WITH KEY.",
"if",
"stmt",
".",
"Op",
",",
"stmt",
".",
"TagKeyExpr",
",",
"err",
"=",
"p",
".",
"parseTagKeyExpr",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse sort: \"ORDER BY FIELD+\".",
"if",
"stmt",
".",
"SortFields",
",",
"err",
"=",
"p",
".",
"parseOrderBy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit: \"LIMIT <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse offset: \"OFFSET <n>\".",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseShowTagValuesStatement parses a string and returns a Statement.
// This function assumes the "SHOW TAG VALUES" tokens have already been consumed. | [
"parseShowTagValuesStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"Statement",
".",
"This",
"function",
"assumes",
"the",
"SHOW",
"TAG",
"VALUES",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1263-L1320 |
11,085 | influxdata/influxql | parser.go | parseShowTagValuesCardinalityStatement | func (p *Parser) parseShowTagValuesCardinalityStatement(exact bool) (Statement, error) {
var err error
stmt := &ShowTagValuesCardinalityStatement{Exact: exact}
if stmt.Exact {
// Parse remaining CARDINALITY token
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != CARDINALITY {
return nil, newParseError(tokstr(tok, lit), []string{"CARDINALITY"}, pos)
}
}
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
if stmt.Database, err = p.ParseIdent(); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional FROM.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse required WITH KEY.
if stmt.Op, stmt.TagKeyExpr, err = p.parseTagKeyExpr(); err != nil {
return nil, err
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse dimensions: "GROUP BY DIMENSION+".
if stmt.Dimensions, err = p.parseDimensions(); err != nil {
return nil, err
}
// Parse limit & offset: "LIMIT <n>", "OFFSET <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
} else if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseShowTagValuesCardinalityStatement(exact bool) (Statement, error) {
var err error
stmt := &ShowTagValuesCardinalityStatement{Exact: exact}
if stmt.Exact {
// Parse remaining CARDINALITY token
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != CARDINALITY {
return nil, newParseError(tokstr(tok, lit), []string{"CARDINALITY"}, pos)
}
}
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
if stmt.Database, err = p.ParseIdent(); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional FROM.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse required WITH KEY.
if stmt.Op, stmt.TagKeyExpr, err = p.parseTagKeyExpr(); err != nil {
return nil, err
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse dimensions: "GROUP BY DIMENSION+".
if stmt.Dimensions, err = p.parseDimensions(); err != nil {
return nil, err
}
// Parse limit & offset: "LIMIT <n>", "OFFSET <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
} else if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowTagValuesCardinalityStatement",
"(",
"exact",
"bool",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"stmt",
":=",
"&",
"ShowTagValuesCardinalityStatement",
"{",
"Exact",
":",
"exact",
"}",
"\n\n",
"if",
"stmt",
".",
"Exact",
"{",
"// Parse remaining CARDINALITY token",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"CARDINALITY",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Parse optional ON clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"if",
"stmt",
".",
"Database",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional FROM.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"FROM",
"{",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse required WITH KEY.",
"if",
"stmt",
".",
"Op",
",",
"stmt",
".",
"TagKeyExpr",
",",
"err",
"=",
"p",
".",
"parseTagKeyExpr",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse dimensions: \"GROUP BY DIMENSION+\".",
"if",
"stmt",
".",
"Dimensions",
",",
"err",
"=",
"p",
".",
"parseDimensions",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit & offset: \"LIMIT <n>\", \"OFFSET <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // This function assumes the "SHOW TAG VALUES" tokens have already been consumed. | [
"This",
"function",
"assumes",
"the",
"SHOW",
"TAG",
"VALUES",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1323-L1375 |
11,086 | influxdata/influxql | parser.go | parseTagKeyExpr | func (p *Parser) parseTagKeyExpr() (Token, Literal, error) {
var err error
// Parse required WITH KEY tokens.
if err := p.parseTokens([]Token{WITH, KEY}); err != nil {
return 0, nil, err
}
// Parse required IN, EQ, or EQREGEX token.
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == IN {
// Parse required ( token.
if tok, pos, lit = p.ScanIgnoreWhitespace(); tok != LPAREN {
return 0, nil, newParseError(tokstr(tok, lit), []string{"("}, pos)
}
// Parse tag key list.
var tagKeys []string
if tagKeys, err = p.ParseIdentList(); err != nil {
return 0, nil, err
}
// Parse required ) token.
if tok, pos, lit = p.ScanIgnoreWhitespace(); tok != RPAREN {
return 0, nil, newParseError(tokstr(tok, lit), []string{")"}, pos)
}
return IN, &ListLiteral{Vals: tagKeys}, nil
} else if tok == EQ || tok == NEQ {
// Parse required tag key.
ident, err := p.ParseIdent()
if err != nil {
return 0, nil, err
}
return tok, &StringLiteral{Val: ident}, nil
} else if tok == EQREGEX || tok == NEQREGEX {
re, err := p.parseRegex()
if err != nil {
return 0, nil, err
} else if re == nil {
// parseRegex can return an empty type, but we need it to be present
tok, pos, lit := p.ScanIgnoreWhitespace()
return 0, nil, newParseError(tokstr(tok, lit), []string{"regex"}, pos)
}
return tok, re, nil
}
return 0, nil, newParseError(tokstr(tok, lit), []string{"IN", "=", "=~"}, pos)
} | go | func (p *Parser) parseTagKeyExpr() (Token, Literal, error) {
var err error
// Parse required WITH KEY tokens.
if err := p.parseTokens([]Token{WITH, KEY}); err != nil {
return 0, nil, err
}
// Parse required IN, EQ, or EQREGEX token.
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok == IN {
// Parse required ( token.
if tok, pos, lit = p.ScanIgnoreWhitespace(); tok != LPAREN {
return 0, nil, newParseError(tokstr(tok, lit), []string{"("}, pos)
}
// Parse tag key list.
var tagKeys []string
if tagKeys, err = p.ParseIdentList(); err != nil {
return 0, nil, err
}
// Parse required ) token.
if tok, pos, lit = p.ScanIgnoreWhitespace(); tok != RPAREN {
return 0, nil, newParseError(tokstr(tok, lit), []string{")"}, pos)
}
return IN, &ListLiteral{Vals: tagKeys}, nil
} else if tok == EQ || tok == NEQ {
// Parse required tag key.
ident, err := p.ParseIdent()
if err != nil {
return 0, nil, err
}
return tok, &StringLiteral{Val: ident}, nil
} else if tok == EQREGEX || tok == NEQREGEX {
re, err := p.parseRegex()
if err != nil {
return 0, nil, err
} else if re == nil {
// parseRegex can return an empty type, but we need it to be present
tok, pos, lit := p.ScanIgnoreWhitespace()
return 0, nil, newParseError(tokstr(tok, lit), []string{"regex"}, pos)
}
return tok, re, nil
}
return 0, nil, newParseError(tokstr(tok, lit), []string{"IN", "=", "=~"}, pos)
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseTagKeyExpr",
"(",
")",
"(",
"Token",
",",
"Literal",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// Parse required WITH KEY tokens.",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"WITH",
",",
"KEY",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse required IN, EQ, or EQREGEX token.",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"==",
"IN",
"{",
"// Parse required ( token.",
"if",
"tok",
",",
"pos",
",",
"lit",
"=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"LPAREN",
"{",
"return",
"0",
",",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Parse tag key list.",
"var",
"tagKeys",
"[",
"]",
"string",
"\n",
"if",
"tagKeys",
",",
"err",
"=",
"p",
".",
"ParseIdentList",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse required ) token.",
"if",
"tok",
",",
"pos",
",",
"lit",
"=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"RPAREN",
"{",
"return",
"0",
",",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"return",
"IN",
",",
"&",
"ListLiteral",
"{",
"Vals",
":",
"tagKeys",
"}",
",",
"nil",
"\n",
"}",
"else",
"if",
"tok",
"==",
"EQ",
"||",
"tok",
"==",
"NEQ",
"{",
"// Parse required tag key.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"tok",
",",
"&",
"StringLiteral",
"{",
"Val",
":",
"ident",
"}",
",",
"nil",
"\n",
"}",
"else",
"if",
"tok",
"==",
"EQREGEX",
"||",
"tok",
"==",
"NEQREGEX",
"{",
"re",
",",
"err",
":=",
"p",
".",
"parseRegex",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"re",
"==",
"nil",
"{",
"// parseRegex can return an empty type, but we need it to be present",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"return",
"0",
",",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"return",
"tok",
",",
"re",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}"
] | // parseTagKeys parses a string and returns a list of tag keys. | [
"parseTagKeys",
"parses",
"a",
"string",
"and",
"returns",
"a",
"list",
"of",
"tag",
"keys",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1378-L1424 |
11,087 | influxdata/influxql | parser.go | parseShowFieldKeyCardinalityStatement | func (p *Parser) parseShowFieldKeyCardinalityStatement() (Statement, error) {
var err error
var exactCardinality bool
requiredTokens := []string{"EXACT", "CARDINALITY"}
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == EXACT {
exactCardinality = true
requiredTokens = requiredTokens[1:]
} else {
p.Unscan()
}
stmt := &ShowFieldKeyCardinalityStatement{Exact: exactCardinality}
// Parse remaining CARDINALITY token
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != CARDINALITY {
return nil, newParseError(tokstr(tok, lit), requiredTokens, pos)
}
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
if stmt.Database, err = p.ParseIdent(); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional FROM.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse dimensions: "GROUP BY DIMENSION+".
if stmt.Dimensions, err = p.parseDimensions(); err != nil {
return nil, err
}
// Parse limit & offset: "LIMIT <n>", "OFFSET <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
} else if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseShowFieldKeyCardinalityStatement() (Statement, error) {
var err error
var exactCardinality bool
requiredTokens := []string{"EXACT", "CARDINALITY"}
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == EXACT {
exactCardinality = true
requiredTokens = requiredTokens[1:]
} else {
p.Unscan()
}
stmt := &ShowFieldKeyCardinalityStatement{Exact: exactCardinality}
// Parse remaining CARDINALITY token
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != CARDINALITY {
return nil, newParseError(tokstr(tok, lit), requiredTokens, pos)
}
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
if stmt.Database, err = p.ParseIdent(); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional FROM.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse condition: "WHERE EXPR".
if stmt.Condition, err = p.parseCondition(); err != nil {
return nil, err
}
// Parse dimensions: "GROUP BY DIMENSION+".
if stmt.Dimensions, err = p.parseDimensions(); err != nil {
return nil, err
}
// Parse limit & offset: "LIMIT <n>", "OFFSET <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
} else if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowFieldKeyCardinalityStatement",
"(",
")",
"(",
"Statement",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"exactCardinality",
"bool",
"\n",
"requiredTokens",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"\n",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"EXACT",
"{",
"exactCardinality",
"=",
"true",
"\n",
"requiredTokens",
"=",
"requiredTokens",
"[",
"1",
":",
"]",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"stmt",
":=",
"&",
"ShowFieldKeyCardinalityStatement",
"{",
"Exact",
":",
"exactCardinality",
"}",
"\n\n",
"// Parse remaining CARDINALITY token",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"CARDINALITY",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"requiredTokens",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Parse optional ON clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"if",
"stmt",
".",
"Database",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional FROM.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"FROM",
"{",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse condition: \"WHERE EXPR\".",
"if",
"stmt",
".",
"Condition",
",",
"err",
"=",
"p",
".",
"parseCondition",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse dimensions: \"GROUP BY DIMENSION+\".",
"if",
"stmt",
".",
"Dimensions",
",",
"err",
"=",
"p",
".",
"parseDimensions",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit & offset: \"LIMIT <n>\", \"OFFSET <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // This function assumes the "SHOW FIELD KEY" tokens have already been consumed. | [
"This",
"function",
"assumes",
"the",
"SHOW",
"FIELD",
"KEY",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1440-L1494 |
11,088 | influxdata/influxql | parser.go | parseShowFieldKeysStatement | func (p *Parser) parseShowFieldKeysStatement() (*ShowFieldKeysStatement, error) {
stmt := &ShowFieldKeysStatement{}
var err error
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional source.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseShowFieldKeysStatement() (*ShowFieldKeysStatement, error) {
stmt := &ShowFieldKeysStatement{}
var err error
// Parse optional ON clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ON {
// Parse the database.
stmt.Database, err = p.ParseIdent()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse optional source.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FROM {
if stmt.Sources, err = p.parseSources(false); err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Parse sort: "ORDER BY FIELD+".
if stmt.SortFields, err = p.parseOrderBy(); err != nil {
return nil, err
}
// Parse limit: "LIMIT <n>".
if stmt.Limit, err = p.ParseOptionalTokenAndInt(LIMIT); err != nil {
return nil, err
}
// Parse offset: "OFFSET <n>".
if stmt.Offset, err = p.ParseOptionalTokenAndInt(OFFSET); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowFieldKeysStatement",
"(",
")",
"(",
"*",
"ShowFieldKeysStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"ShowFieldKeysStatement",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n\n",
"// Parse optional ON clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ON",
"{",
"// Parse the database.",
"stmt",
".",
"Database",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse optional source.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"FROM",
"{",
"if",
"stmt",
".",
"Sources",
",",
"err",
"=",
"p",
".",
"parseSources",
"(",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Parse sort: \"ORDER BY FIELD+\".",
"if",
"stmt",
".",
"SortFields",
",",
"err",
"=",
"p",
".",
"parseOrderBy",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse limit: \"LIMIT <n>\".",
"if",
"stmt",
".",
"Limit",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"LIMIT",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse offset: \"OFFSET <n>\".",
"if",
"stmt",
".",
"Offset",
",",
"err",
"=",
"p",
".",
"ParseOptionalTokenAndInt",
"(",
"OFFSET",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseShowFieldKeysStatement parses a string and returns a Statement.
// This function assumes the "SHOW FIELD KEYS" tokens have already been consumed. | [
"parseShowFieldKeysStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"Statement",
".",
"This",
"function",
"assumes",
"the",
"SHOW",
"FIELD",
"KEYS",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1498-L1538 |
11,089 | influxdata/influxql | parser.go | parseDropMeasurementStatement | func (p *Parser) parseDropMeasurementStatement() (*DropMeasurementStatement, error) {
stmt := &DropMeasurementStatement{}
// Parse the name of the measurement to be dropped.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
return stmt, nil
} | go | func (p *Parser) parseDropMeasurementStatement() (*DropMeasurementStatement, error) {
stmt := &DropMeasurementStatement{}
// Parse the name of the measurement to be dropped.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseDropMeasurementStatement",
"(",
")",
"(",
"*",
"DropMeasurementStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"DropMeasurementStatement",
"{",
"}",
"\n\n",
"// Parse the name of the measurement to be dropped.",
"lit",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"lit",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseDropMeasurementStatement parses a string and returns a DropMeasurementStatement.
// This function assumes the "DROP MEASUREMENT" tokens have already been consumed. | [
"parseDropMeasurementStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"DropMeasurementStatement",
".",
"This",
"function",
"assumes",
"the",
"DROP",
"MEASUREMENT",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1542-L1553 |
11,090 | influxdata/influxql | parser.go | parseDropShardStatement | func (p *Parser) parseDropShardStatement() (*DropShardStatement, error) {
var err error
stmt := &DropShardStatement{}
// Parse the ID of the shard to be dropped.
if stmt.ID, err = p.ParseUInt64(); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseDropShardStatement() (*DropShardStatement, error) {
var err error
stmt := &DropShardStatement{}
// Parse the ID of the shard to be dropped.
if stmt.ID, err = p.ParseUInt64(); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseDropShardStatement",
"(",
")",
"(",
"*",
"DropShardStatement",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"stmt",
":=",
"&",
"DropShardStatement",
"{",
"}",
"\n\n",
"// Parse the ID of the shard to be dropped.",
"if",
"stmt",
".",
"ID",
",",
"err",
"=",
"p",
".",
"ParseUInt64",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseDropShardStatement parses a string and returns a
// DropShardStatement. This function assumes the "DROP SHARD" tokens
// have already been consumed. | [
"parseDropShardStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"DropShardStatement",
".",
"This",
"function",
"assumes",
"the",
"DROP",
"SHARD",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1606-L1615 |
11,091 | influxdata/influxql | parser.go | parseGrantsForUserStatement | func (p *Parser) parseGrantsForUserStatement() (*ShowGrantsForUserStatement, error) {
stmt := &ShowGrantsForUserStatement{}
// Parse the name of the user to be displayed.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
return stmt, nil
} | go | func (p *Parser) parseGrantsForUserStatement() (*ShowGrantsForUserStatement, error) {
stmt := &ShowGrantsForUserStatement{}
// Parse the name of the user to be displayed.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseGrantsForUserStatement",
"(",
")",
"(",
"*",
"ShowGrantsForUserStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"ShowGrantsForUserStatement",
"{",
"}",
"\n\n",
"// Parse the name of the user to be displayed.",
"lit",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"lit",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseGrantsForUserStatement parses a string and returns a ShowGrantsForUserStatement.
// This function assumes the "SHOW GRANTS" tokens have already been consumed. | [
"parseGrantsForUserStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"ShowGrantsForUserStatement",
".",
"This",
"function",
"assumes",
"the",
"SHOW",
"GRANTS",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1625-L1636 |
11,092 | influxdata/influxql | parser.go | parseCreateContinuousQueryStatement | func (p *Parser) parseCreateContinuousQueryStatement() (*CreateContinuousQueryStatement, error) {
stmt := &CreateContinuousQueryStatement{}
// Read the id of the query to create.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Expect an "ON" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Read the name of the database to create the query on.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.Database = ident
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == RESAMPLE {
stmt.ResampleEvery, stmt.ResampleFor, err = p.parseResample()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Expect a "BEGIN SELECT" tokens.
if err := p.parseTokens([]Token{BEGIN, SELECT}); err != nil {
return nil, err
}
// Read the select statement to be used as the source.
source, err := p.parseSelectStatement(targetRequired)
if err != nil {
return nil, err
}
stmt.Source = source
// validate that the statement has a non-zero group by interval if it is aggregated
if !source.IsRawQuery {
d, err := source.GroupByInterval()
if d == 0 || err != nil {
// rewind so we can output an error with some info
p.Unscan() // Unscan the whitespace
p.Unscan() // Unscan the last token
tok, pos, lit := p.ScanIgnoreWhitespace()
expected := []string{"GROUP BY time(...)"}
if err != nil {
expected = append(expected, err.Error())
}
return nil, newParseError(tokstr(tok, lit), expected, pos)
}
}
// Expect a "END" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != END {
return nil, newParseError(tokstr(tok, lit), []string{"END"}, pos)
}
if err := stmt.validate(); err != nil {
return nil, err
}
return stmt, nil
} | go | func (p *Parser) parseCreateContinuousQueryStatement() (*CreateContinuousQueryStatement, error) {
stmt := &CreateContinuousQueryStatement{}
// Read the id of the query to create.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Expect an "ON" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Read the name of the database to create the query on.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.Database = ident
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == RESAMPLE {
stmt.ResampleEvery, stmt.ResampleFor, err = p.parseResample()
if err != nil {
return nil, err
}
} else {
p.Unscan()
}
// Expect a "BEGIN SELECT" tokens.
if err := p.parseTokens([]Token{BEGIN, SELECT}); err != nil {
return nil, err
}
// Read the select statement to be used as the source.
source, err := p.parseSelectStatement(targetRequired)
if err != nil {
return nil, err
}
stmt.Source = source
// validate that the statement has a non-zero group by interval if it is aggregated
if !source.IsRawQuery {
d, err := source.GroupByInterval()
if d == 0 || err != nil {
// rewind so we can output an error with some info
p.Unscan() // Unscan the whitespace
p.Unscan() // Unscan the last token
tok, pos, lit := p.ScanIgnoreWhitespace()
expected := []string{"GROUP BY time(...)"}
if err != nil {
expected = append(expected, err.Error())
}
return nil, newParseError(tokstr(tok, lit), expected, pos)
}
}
// Expect a "END" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != END {
return nil, newParseError(tokstr(tok, lit), []string{"END"}, pos)
}
if err := stmt.validate(); err != nil {
return nil, err
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseCreateContinuousQueryStatement",
"(",
")",
"(",
"*",
"CreateContinuousQueryStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"CreateContinuousQueryStatement",
"{",
"}",
"\n\n",
"// Read the id of the query to create.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"ident",
"\n\n",
"// Expect an \"ON\" keyword.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"ON",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Read the name of the database to create the query on.",
"if",
"ident",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Database",
"=",
"ident",
"\n\n",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"RESAMPLE",
"{",
"stmt",
".",
"ResampleEvery",
",",
"stmt",
".",
"ResampleFor",
",",
"err",
"=",
"p",
".",
"parseResample",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"// Expect a \"BEGIN SELECT\" tokens.",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"BEGIN",
",",
"SELECT",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Read the select statement to be used as the source.",
"source",
",",
"err",
":=",
"p",
".",
"parseSelectStatement",
"(",
"targetRequired",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Source",
"=",
"source",
"\n\n",
"// validate that the statement has a non-zero group by interval if it is aggregated",
"if",
"!",
"source",
".",
"IsRawQuery",
"{",
"d",
",",
"err",
":=",
"source",
".",
"GroupByInterval",
"(",
")",
"\n",
"if",
"d",
"==",
"0",
"||",
"err",
"!=",
"nil",
"{",
"// rewind so we can output an error with some info",
"p",
".",
"Unscan",
"(",
")",
"// Unscan the whitespace",
"\n",
"p",
".",
"Unscan",
"(",
")",
"// Unscan the last token",
"\n",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"expected",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"expected",
"=",
"append",
"(",
"expected",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"expected",
",",
"pos",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Expect a \"END\" keyword.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"END",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"stmt",
".",
"validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseCreateContinuousQueriesStatement parses a string and returns a CreateContinuousQueryStatement.
// This function assumes the "CREATE CONTINUOUS" tokens have already been consumed. | [
"parseCreateContinuousQueriesStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"CreateContinuousQueryStatement",
".",
"This",
"function",
"assumes",
"the",
"CREATE",
"CONTINUOUS",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1646-L1714 |
11,093 | influxdata/influxql | parser.go | parseCreateDatabaseStatement | func (p *Parser) parseCreateDatabaseStatement() (*CreateDatabaseStatement, error) {
stmt := &CreateDatabaseStatement{}
// Parse the name of the database to be created.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
// Look for "WITH"
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == WITH {
// validate that at least one of DURATION, NAME, REPLICATION or SHARD is provided
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != DURATION && tok != NAME && tok != REPLICATION && tok != SHARD {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION", "NAME", "REPLICATION", "SHARD"}, pos)
}
// rewind
p.Unscan()
// mark statement as having a RetentionPolicyInfo defined
stmt.RetentionPolicyCreate = true
// Look for "DURATION"
if err := p.parseTokens([]Token{DURATION}); err != nil {
p.Unscan()
} else {
rpDuration, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.RetentionPolicyDuration = &rpDuration
}
// Look for "REPLICATION"
if err := p.parseTokens([]Token{REPLICATION}); err != nil {
p.Unscan()
} else {
rpReplication, err := p.ParseInt(1, math.MaxInt32)
if err != nil {
return nil, err
}
stmt.RetentionPolicyReplication = &rpReplication
}
// Look for "SHARD"
if err := p.parseTokens([]Token{SHARD}); err != nil {
p.Unscan()
} else {
// Look for "DURATION"
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != DURATION {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION"}, pos)
}
stmt.RetentionPolicyShardGroupDuration, err = p.ParseDuration()
if err != nil {
return nil, err
}
}
// Look for "NAME"
if err := p.parseTokens([]Token{NAME}); err != nil {
p.Unscan()
} else {
stmt.RetentionPolicyName, err = p.ParseIdent()
if err != nil {
return nil, err
}
}
} else {
p.Unscan()
}
return stmt, nil
} | go | func (p *Parser) parseCreateDatabaseStatement() (*CreateDatabaseStatement, error) {
stmt := &CreateDatabaseStatement{}
// Parse the name of the database to be created.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
// Look for "WITH"
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == WITH {
// validate that at least one of DURATION, NAME, REPLICATION or SHARD is provided
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != DURATION && tok != NAME && tok != REPLICATION && tok != SHARD {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION", "NAME", "REPLICATION", "SHARD"}, pos)
}
// rewind
p.Unscan()
// mark statement as having a RetentionPolicyInfo defined
stmt.RetentionPolicyCreate = true
// Look for "DURATION"
if err := p.parseTokens([]Token{DURATION}); err != nil {
p.Unscan()
} else {
rpDuration, err := p.ParseDuration()
if err != nil {
return nil, err
}
stmt.RetentionPolicyDuration = &rpDuration
}
// Look for "REPLICATION"
if err := p.parseTokens([]Token{REPLICATION}); err != nil {
p.Unscan()
} else {
rpReplication, err := p.ParseInt(1, math.MaxInt32)
if err != nil {
return nil, err
}
stmt.RetentionPolicyReplication = &rpReplication
}
// Look for "SHARD"
if err := p.parseTokens([]Token{SHARD}); err != nil {
p.Unscan()
} else {
// Look for "DURATION"
tok, pos, lit := p.ScanIgnoreWhitespace()
if tok != DURATION {
return nil, newParseError(tokstr(tok, lit), []string{"DURATION"}, pos)
}
stmt.RetentionPolicyShardGroupDuration, err = p.ParseDuration()
if err != nil {
return nil, err
}
}
// Look for "NAME"
if err := p.parseTokens([]Token{NAME}); err != nil {
p.Unscan()
} else {
stmt.RetentionPolicyName, err = p.ParseIdent()
if err != nil {
return nil, err
}
}
} else {
p.Unscan()
}
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseCreateDatabaseStatement",
"(",
")",
"(",
"*",
"CreateDatabaseStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"CreateDatabaseStatement",
"{",
"}",
"\n\n",
"// Parse the name of the database to be created.",
"lit",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"lit",
"\n\n",
"// Look for \"WITH\"",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"WITH",
"{",
"// validate that at least one of DURATION, NAME, REPLICATION or SHARD is provided",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"!=",
"DURATION",
"&&",
"tok",
"!=",
"NAME",
"&&",
"tok",
"!=",
"REPLICATION",
"&&",
"tok",
"!=",
"SHARD",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"// rewind",
"p",
".",
"Unscan",
"(",
")",
"\n\n",
"// mark statement as having a RetentionPolicyInfo defined",
"stmt",
".",
"RetentionPolicyCreate",
"=",
"true",
"\n\n",
"// Look for \"DURATION\"",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"DURATION",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"else",
"{",
"rpDuration",
",",
"err",
":=",
"p",
".",
"ParseDuration",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"RetentionPolicyDuration",
"=",
"&",
"rpDuration",
"\n",
"}",
"\n\n",
"// Look for \"REPLICATION\"",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"REPLICATION",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"else",
"{",
"rpReplication",
",",
"err",
":=",
"p",
".",
"ParseInt",
"(",
"1",
",",
"math",
".",
"MaxInt32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"RetentionPolicyReplication",
"=",
"&",
"rpReplication",
"\n",
"}",
"\n\n",
"// Look for \"SHARD\"",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"SHARD",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"else",
"{",
"// Look for \"DURATION\"",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
"\n",
"if",
"tok",
"!=",
"DURATION",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n",
"stmt",
".",
"RetentionPolicyShardGroupDuration",
",",
"err",
"=",
"p",
".",
"ParseDuration",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Look for \"NAME\"",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"NAME",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"else",
"{",
"stmt",
".",
"RetentionPolicyName",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseCreateDatabaseStatement parses a string and returns a CreateDatabaseStatement.
// This function assumes the "CREATE DATABASE" tokens have already been consumed. | [
"parseCreateDatabaseStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"CreateDatabaseStatement",
".",
"This",
"function",
"assumes",
"the",
"CREATE",
"DATABASE",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1718-L1791 |
11,094 | influxdata/influxql | parser.go | parseDropDatabaseStatement | func (p *Parser) parseDropDatabaseStatement() (*DropDatabaseStatement, error) {
stmt := &DropDatabaseStatement{}
// Parse the name of the database to be dropped.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
return stmt, nil
} | go | func (p *Parser) parseDropDatabaseStatement() (*DropDatabaseStatement, error) {
stmt := &DropDatabaseStatement{}
// Parse the name of the database to be dropped.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseDropDatabaseStatement",
"(",
")",
"(",
"*",
"DropDatabaseStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"DropDatabaseStatement",
"{",
"}",
"\n\n",
"// Parse the name of the database to be dropped.",
"lit",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"lit",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseDropDatabaseStatement parses a string and returns a DropDatabaseStatement.
// This function assumes the DROP DATABASE tokens have already been consumed. | [
"parseDropDatabaseStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"DropDatabaseStatement",
".",
"This",
"function",
"assumes",
"the",
"DROP",
"DATABASE",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1795-L1806 |
11,095 | influxdata/influxql | parser.go | parseDropSubscriptionStatement | func (p *Parser) parseDropSubscriptionStatement() (*DropSubscriptionStatement, error) {
stmt := &DropSubscriptionStatement{}
// Read the id of the subscription to drop.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Expect an "ON" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Read the name of the database.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.Database = ident
if tok, pos, lit := p.Scan(); tok != DOT {
return nil, newParseError(tokstr(tok, lit), []string{"."}, pos)
}
// Read the name of the retention policy.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.RetentionPolicy = ident
return stmt, nil
} | go | func (p *Parser) parseDropSubscriptionStatement() (*DropSubscriptionStatement, error) {
stmt := &DropSubscriptionStatement{}
// Read the id of the subscription to drop.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Expect an "ON" keyword.
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != ON {
return nil, newParseError(tokstr(tok, lit), []string{"ON"}, pos)
}
// Read the name of the database.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.Database = ident
if tok, pos, lit := p.Scan(); tok != DOT {
return nil, newParseError(tokstr(tok, lit), []string{"."}, pos)
}
// Read the name of the retention policy.
if ident, err = p.ParseIdent(); err != nil {
return nil, err
}
stmt.RetentionPolicy = ident
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseDropSubscriptionStatement",
"(",
")",
"(",
"*",
"DropSubscriptionStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"DropSubscriptionStatement",
"{",
"}",
"\n\n",
"// Read the id of the subscription to drop.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"ident",
"\n\n",
"// Expect an \"ON\" keyword.",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"ON",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Read the name of the database.",
"if",
"ident",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Database",
"=",
"ident",
"\n\n",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"Scan",
"(",
")",
";",
"tok",
"!=",
"DOT",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"// Read the name of the retention policy.",
"if",
"ident",
",",
"err",
"=",
"p",
".",
"ParseIdent",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"RetentionPolicy",
"=",
"ident",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseDropSubscriptionStatement parses a string and returns a DropSubscriptionStatement.
// This function assumes the "DROP SUBSCRIPTION" tokens have already been consumed. | [
"parseDropSubscriptionStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"DropSubscriptionStatement",
".",
"This",
"function",
"assumes",
"the",
"DROP",
"SUBSCRIPTION",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1810-L1842 |
11,096 | influxdata/influxql | parser.go | parseCreateUserStatement | func (p *Parser) parseCreateUserStatement() (*CreateUserStatement, error) {
stmt := &CreateUserStatement{}
// Parse name of the user to be created.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Consume "WITH PASSWORD" tokens
if err := p.parseTokens([]Token{WITH, PASSWORD}); err != nil {
return nil, err
}
// Parse new user's password
if ident, err = p.parseString(); err != nil {
return nil, err
}
stmt.Password = ident
// Check for option WITH clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok != WITH {
p.Unscan()
return stmt, nil
}
// "WITH ALL PRIVILEGES" grants the new user admin privilege.
// Only admin privilege can be set on user creation.
if err := p.parseTokens([]Token{ALL, PRIVILEGES}); err != nil {
return nil, err
}
stmt.Admin = true
return stmt, nil
} | go | func (p *Parser) parseCreateUserStatement() (*CreateUserStatement, error) {
stmt := &CreateUserStatement{}
// Parse name of the user to be created.
ident, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = ident
// Consume "WITH PASSWORD" tokens
if err := p.parseTokens([]Token{WITH, PASSWORD}); err != nil {
return nil, err
}
// Parse new user's password
if ident, err = p.parseString(); err != nil {
return nil, err
}
stmt.Password = ident
// Check for option WITH clause.
if tok, _, _ := p.ScanIgnoreWhitespace(); tok != WITH {
p.Unscan()
return stmt, nil
}
// "WITH ALL PRIVILEGES" grants the new user admin privilege.
// Only admin privilege can be set on user creation.
if err := p.parseTokens([]Token{ALL, PRIVILEGES}); err != nil {
return nil, err
}
stmt.Admin = true
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseCreateUserStatement",
"(",
")",
"(",
"*",
"CreateUserStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"CreateUserStatement",
"{",
"}",
"\n\n",
"// Parse name of the user to be created.",
"ident",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"ident",
"\n\n",
"// Consume \"WITH PASSWORD\" tokens",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"WITH",
",",
"PASSWORD",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Parse new user's password",
"if",
"ident",
",",
"err",
"=",
"p",
".",
"parseString",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Password",
"=",
"ident",
"\n\n",
"// Check for option WITH clause.",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"WITH",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"return",
"stmt",
",",
"nil",
"\n",
"}",
"\n\n",
"// \"WITH ALL PRIVILEGES\" grants the new user admin privilege.",
"// Only admin privilege can be set on user creation.",
"if",
"err",
":=",
"p",
".",
"parseTokens",
"(",
"[",
"]",
"Token",
"{",
"ALL",
",",
"PRIVILEGES",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Admin",
"=",
"true",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseCreateUserStatement parses a string and returns a CreateUserStatement.
// This function assumes the "CREATE USER" tokens have already been consumed. | [
"parseCreateUserStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"CreateUserStatement",
".",
"This",
"function",
"assumes",
"the",
"CREATE",
"USER",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1871-L1906 |
11,097 | influxdata/influxql | parser.go | parseDropUserStatement | func (p *Parser) parseDropUserStatement() (*DropUserStatement, error) {
stmt := &DropUserStatement{}
// Parse the name of the user to be dropped.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
return stmt, nil
} | go | func (p *Parser) parseDropUserStatement() (*DropUserStatement, error) {
stmt := &DropUserStatement{}
// Parse the name of the user to be dropped.
lit, err := p.ParseIdent()
if err != nil {
return nil, err
}
stmt.Name = lit
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseDropUserStatement",
"(",
")",
"(",
"*",
"DropUserStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"DropUserStatement",
"{",
"}",
"\n\n",
"// Parse the name of the user to be dropped.",
"lit",
",",
"err",
":=",
"p",
".",
"ParseIdent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Name",
"=",
"lit",
"\n\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseDropUserStatement parses a string and returns a DropUserStatement.
// This function assumes the DROP USER tokens have already been consumed. | [
"parseDropUserStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"DropUserStatement",
".",
"This",
"function",
"assumes",
"the",
"DROP",
"USER",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1910-L1921 |
11,098 | influxdata/influxql | parser.go | parseExplainStatement | func (p *Parser) parseExplainStatement() (*ExplainStatement, error) {
stmt := &ExplainStatement{}
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ANALYZE {
stmt.Analyze = true
} else {
p.Unscan()
}
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != SELECT {
return nil, newParseError(tokstr(tok, lit), []string{"SELECT"}, pos)
}
s, err := p.parseSelectStatement(targetNotRequired)
if err != nil {
return nil, err
}
stmt.Statement = s
return stmt, nil
} | go | func (p *Parser) parseExplainStatement() (*ExplainStatement, error) {
stmt := &ExplainStatement{}
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == ANALYZE {
stmt.Analyze = true
} else {
p.Unscan()
}
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != SELECT {
return nil, newParseError(tokstr(tok, lit), []string{"SELECT"}, pos)
}
s, err := p.parseSelectStatement(targetNotRequired)
if err != nil {
return nil, err
}
stmt.Statement = s
return stmt, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseExplainStatement",
"(",
")",
"(",
"*",
"ExplainStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"ExplainStatement",
"{",
"}",
"\n\n",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"ANALYZE",
"{",
"stmt",
".",
"Analyze",
"=",
"true",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"tok",
",",
"pos",
",",
"lit",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"!=",
"SELECT",
"{",
"return",
"nil",
",",
"newParseError",
"(",
"tokstr",
"(",
"tok",
",",
"lit",
")",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"pos",
")",
"\n",
"}",
"\n\n",
"s",
",",
"err",
":=",
"p",
".",
"parseSelectStatement",
"(",
"targetNotRequired",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stmt",
".",
"Statement",
"=",
"s",
"\n",
"return",
"stmt",
",",
"nil",
"\n",
"}"
] | // parseExplainStatement parses a string and return an ExplainStatement.
// This function assumes the EXPLAIN token has already been consumed. | [
"parseExplainStatement",
"parses",
"a",
"string",
"and",
"return",
"an",
"ExplainStatement",
".",
"This",
"function",
"assumes",
"the",
"EXPLAIN",
"token",
"has",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1925-L1944 |
11,099 | influxdata/influxql | parser.go | parseShowStatsStatement | func (p *Parser) parseShowStatsStatement() (*ShowStatsStatement, error) {
stmt := &ShowStatsStatement{}
var err error
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FOR {
stmt.Module, err = p.parseString()
} else {
p.Unscan()
}
return stmt, err
} | go | func (p *Parser) parseShowStatsStatement() (*ShowStatsStatement, error) {
stmt := &ShowStatsStatement{}
var err error
if tok, _, _ := p.ScanIgnoreWhitespace(); tok == FOR {
stmt.Module, err = p.parseString()
} else {
p.Unscan()
}
return stmt, err
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"parseShowStatsStatement",
"(",
")",
"(",
"*",
"ShowStatsStatement",
",",
"error",
")",
"{",
"stmt",
":=",
"&",
"ShowStatsStatement",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"tok",
",",
"_",
",",
"_",
":=",
"p",
".",
"ScanIgnoreWhitespace",
"(",
")",
";",
"tok",
"==",
"FOR",
"{",
"stmt",
".",
"Module",
",",
"err",
"=",
"p",
".",
"parseString",
"(",
")",
"\n",
"}",
"else",
"{",
"p",
".",
"Unscan",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"stmt",
",",
"err",
"\n",
"}"
] | // parseShowStatsStatement parses a string and returns a ShowStatsStatement.
// This function assumes the "SHOW STATS" tokens have already been consumed. | [
"parseShowStatsStatement",
"parses",
"a",
"string",
"and",
"returns",
"a",
"ShowStatsStatement",
".",
"This",
"function",
"assumes",
"the",
"SHOW",
"STATS",
"tokens",
"have",
"already",
"been",
"consumed",
"."
] | 1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513 | https://github.com/influxdata/influxql/blob/1cbfca8e56b6eaa120f5b5161e4f0d5edcc9e513/parser.go#L1960-L1971 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.