mirror of
https://github.com/featurebasedb/featurebase.git
synced 2026-08-28 10:54:59 +00:00
3b696da34a
So in some cases, when we do a query, the results of one part of the query are innately shared-across-nodes; for instance, a hypothetical Distinct query. More generally, we allow cross-index queries; calls can have "index=foo" in them. This patch lets us handle that without duplicating that query all over. Before we actually start doing the separate calls, we run the query once from the coordinating node, then patch the results in, and send relevant subsets over to each client, etcetera. Also provides slightly friendlier (and I hope faster) support for converting bitmaps to/from sets of rows. We also add an extension interface, and some fancy stuff to let us define new calls, which use this. They're sort of tied together because the first extension I wanted to implement needed precomputed calls. The extension API lets us create extensions using `pkg/plugin` (with all its associated limitations, unfortunately), then query them at load time for functionality. This also implies some revamping of the argument validation for PQL, like verifying that functions exist and knowing things about their argument types. So basically this is an overly intrusive patch, and would be better as separate patches, but they're hard to detangle. add trivial execution-time profiling What if you could ?profile=true on a query and get some numbers back? That'd be really cool. We already have tracing/spans, but right now, those only generate any data if you have something set up for them to trace to. Add a fancy wrapper that lets us generate our own tracing data, and dump it into the request response, if ?profile=true. add a sample extension, add missing features to extension interface Implement a naive probabilistic filter extension as an example of what an extension looks like. In the process, discover multiple omissions in the bitmap API. Well, I did *say* it was experimental.
95 lines
2.3 KiB
Go
95 lines
2.3 KiB
Go
// Copyright 2017 Pilosa Corp.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package pql
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"strings"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// timeFormat is the go-style time format used to parse string dates.
|
|
const timeFormat = "2006-01-02T15:04"
|
|
|
|
// error strings in the parser
|
|
const duplicateArgErrorMessage = "duplicate argument provided"
|
|
const intOutOfRangeError = "integer is not in signed 64-bit range"
|
|
|
|
// parser represents a parser for the PQL language.
|
|
type parser struct {
|
|
r io.Reader
|
|
//scanner *bufScanner
|
|
PQL
|
|
}
|
|
|
|
// NewParser returns a new instance of Parser.
|
|
func NewParser(r io.Reader) *parser {
|
|
return &parser{
|
|
r: r,
|
|
// scanner: newBufScanner(r),
|
|
}
|
|
}
|
|
|
|
// ParseString parses s into a query.
|
|
func ParseString(s string) (*Query, error) {
|
|
return NewParser(strings.NewReader(s)).Parse()
|
|
}
|
|
|
|
// Parse parses the next node in the query.
|
|
func (p *parser) Parse() (*Query, error) {
|
|
buf, err := ioutil.ReadAll(p.r)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "reading buffer to parse")
|
|
}
|
|
p.PQL = PQL{
|
|
Buffer: string(buf),
|
|
}
|
|
p.Init()
|
|
err = p.PQL.Parse()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "parsing")
|
|
}
|
|
|
|
// Handle specific panics from the parser and return them as errors.
|
|
var v interface{}
|
|
func() {
|
|
defer func() { v = recover() }()
|
|
p.Execute()
|
|
}()
|
|
if v != nil {
|
|
errorMessage, ok := v.(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("unexpected parser error of type %T: %[1]v", v)
|
|
}
|
|
if strings.HasPrefix(errorMessage, duplicateArgErrorMessage) || strings.HasPrefix(errorMessage, intOutOfRangeError) {
|
|
return nil, fmt.Errorf("%s", v)
|
|
} else {
|
|
panic(v)
|
|
}
|
|
}
|
|
for _, call := range p.Query.Calls {
|
|
if call == nil {
|
|
return nil, fmt.Errorf("unexpected nil Call in query's call list")
|
|
}
|
|
if err := call.CheckCallInfo(); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return &p.Query, nil
|
|
}
|