// Raw returns the query, everything after the --name tag
549811
func (d DotSql) Raw(name string) (string, error) {
	return d.lookupQuery(name)
}
1059761
func (this *Engine) RawQueryKv(key string, val string, sql string, params ...interface{}) map[string]string {
	results := make(map[string]string, 0)
	err := this.RawQueryCallback(func(rows *core.Rows, fields []string) {
		result := make(map[string]string)
		StrRowProcessing(rows, fields, func(data string, index int, fieldName string) {
			result[fieldName] = data
		})
		if k, ok := result[key]; ok {
			if v, ok := result[val]; ok {
				results[k] = v
			}
		}
	}, sql, params...)
	if err != nil {
		this.TLogger.Base.Error(err)
	}
	return results
}
770091
func (tr *Reader) RawBytes() []byte {
	if !tr.RawAccounting {
		return nil
	}
	if tr.rawBytes == nil {
		tr.rawBytes = bytes.NewBuffer(nil)
	}
	defer tr.rawBytes.Reset() // if we've read them, then flush them.

	return tr.rawBytes.Bytes()

}
845499
func (q WildcardQuery) Name(name string) WildcardQuery {
	q.name = name
	return q
}
805293
func (c *Client) rawRequest(verb string, u *url.URL, ro *RequestOptions) (*http.Request, error) {
	if verb == "" {
		return nil, fmt.Errorf("client: missing verb")
	}

	if u == nil {
		return nil, fmt.Errorf("client: missing URL.url")
	}

	if ro == nil {
		return nil, fmt.Errorf("client: missing RequestOptions")
	}

	// Add the token and other params
	var params = make(url.Values)
	for k, v := range ro.Params {
		params.Add(k, v)
	}
	u.RawQuery = params.Encode()

	// Create the request object
	request, err := http.NewRequest(verb, u.String(), ro.Body)
	if err != nil {
		return nil, err
	}

	// set our default headers first
	for k, v := range c.DefaultHeader {
		request.Header[k] = v
	}

	// Add any request headers (auth will be here if set)
	for k, v := range ro.Headers {
		request.Header.Add(k, v)
	}

	// Add content-length if we have it
	if ro.BodyLength > 0 {
		request.ContentLength = ro.BodyLength
	}

	log.Printf("[DEBUG] raw request: %#v", request)

	return request, nil
}
437582
func (w *mlWriter) Raw(raw string) error {
	w.writeIndent(true)
	if err := w.activePlugin().Raw(raw); err != nil {
		return err
	}
	w.writeNewline()
	return nil
}
664482
func (r *Response) Raw(data []byte) error {
	r.data = data
	return nil
}
383821
func (raw *Raw) Query(endpoint string, out interface{}, q *QueryOptions) (*QueryMeta, error) {
	return raw.c.query(endpoint, out, q)
}
314534
func InsertBySql(query string, value ...interface{}) *InsertStmt {
	return &InsertStmt{
		raw: raw{
			Query: query,
			Value: value,
		},
	}
}
1254190
func (u *URL) Query() Values {
	v, _ := ParseQuery(u.RawQuery)
	return v
}
1262881
func (ctx *Context) Query(name string) string {
	if ctx.query == nil {
		ctx.query = ctx.Req.URL.Query()
	}
	return ctx.query.Get(name)
}
208491
func (g *GroupComposer) Raw() interface{} {
	if len(g.messages) == 1 && g.messages[0].Loggable() {
		return g.messages[0].Raw()
	}

	out := []interface{}{}
	for _, m := range g.messages {
		if m == nil {
			continue
		}
		if m.Loggable() {
			out = append(out, m.Raw())
		}
	}

	return out
}
105156
func (api *API) Raw(method, endpoint string, data interface{}) (json.RawMessage, error) {
	res, err := api.makeRequest(method, endpoint, data)
	if err != nil {
		return nil, errors.Wrap(err, errMakeRequestError)
	}

	var r RawResponse
	if err := json.Unmarshal(res, &r); err != nil {
		return nil, errors.Wrap(err, errUnmarshalError)
	}
	return r.Result, nil
}
745463
func (m Match) RawHandler() HandlerType {
	switch v := m.Handler.(type) {
	case netHTTPHandlerWrap:
		return v.Handler
	case handlerFuncWrap:
		return v.fn
	case netHTTPHandlerFuncWrap:
		return v.fn
	default:
		return v
	}
}
766884
func (z *Tokenizer) Raw() []byte {
	return z.buf[z.raw.start:z.raw.end]
}
725977
func (c *Context) Query(name string) string {
	return c.request.URL.Query().Get(name)
}
884194
func (c *Context) RAWContent() ([]byte, error) {
	res := c.Response()
	defer res.Body.Close()
	return ioutil.ReadAll(res.Body)
}