code: func (c *InternalClient) importNode(ctx context.Context, node *pilosa.Node, index, field string, buf []byte, opts *pilosa.ImportOptions) error {
  	span, ctx := tracing.StartSpanFromContext(ctx, "InternalClient.importNode")
  	defer span.Finish()
  
  	// Create URL & HTTP request.
  	path := fmt.Sprintf("/index/%s/field/%s/import", index, field)
  	u := nodePathToURL(node, path)
  
  	vals := url.Values{}
  	if opts.Clear {
  		vals.Set("clear", "true")
  	}
  	if opts.IgnoreKeyCheck {
  		vals.Set("ignoreKeyCheck", "true")
  	}
  	url := fmt.Sprintf("%s?%s", u.String(), vals.Encode())
  
  	req, err := http.NewRequest("POST", url, bytes.NewReader(buf))
  	if err != nil {
  		return errors.Wrap(err, "creating request")
  	}
  	req.Header.Set("Content-Length", strconv.Itoa(len(buf)))
  	req.Header.Set("Content-Type", "application/x-protobuf")
  	req.Header.Set("Accept", "application/x-protobuf")
  	req.Header.Set("User-Agent", "pilosa/"+pilosa.Version)
  
  	// Execute request against the host.
  	resp, err := c.executeRequest(req.WithContext(ctx))
  	if err != nil {
  		return err
  	}
  	defer resp.Body.Close()
  
  	// Read body and unmarshal response.
  	body, err := ioutil.ReadAll(resp.Body)
  	if err != nil {
  		return errors.Wrap(err, "reading")
  	}
  
  	var isresp pilosa.ImportResponse
  	if err := c.serializer.Unmarshal(body, &isresp); err != nil {
  		return fmt.Errorf("unmarshal import response: %s", err)
  	} else if s := isresp.Err; s != "" {
  		return errors.New(s)
  	}
  
  	return nil
  }
docs: // importNode sends a pre-marshaled import request to a node.