query

package
v0.0.0-...-09f9b81 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 23, 2021 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AllRunningQueriesNotFound 

type AllRunningQueriesNotFound struct {
	Payload *models.Error
}
AllRunningQueriesNotFound describes a response with status code 404, with default header values.

Not Found

func NewAllRunningQueriesNotFound 

func NewAllRunningQueriesNotFound() *AllRunningQueriesNotFound

NewAllRunningQueriesNotFound creates a AllRunningQueriesNotFound with default headers values

func (*AllRunningQueriesNotFound) Error 

func (o *AllRunningQueriesNotFound) Error() string

func (*AllRunningQueriesNotFound) GetPayload 

func (o *AllRunningQueriesNotFound) GetPayload() *models.Error

type AllRunningQueriesOK 

type AllRunningQueriesOK struct {
	Payload []*models.RunningQueries
}
AllRunningQueriesOK describes a response with status code 200, with default header values.

Running Queries.

func NewAllRunningQueriesOK 

func NewAllRunningQueriesOK() *AllRunningQueriesOK

NewAllRunningQueriesOK creates a AllRunningQueriesOK with default headers values

func (*AllRunningQueriesOK) Error 

func (o *AllRunningQueriesOK) Error() string

func (*AllRunningQueriesOK) GetPayload 

func (o *AllRunningQueriesOK) GetPayload() []*models.RunningQueries

type AllRunningQueriesParams 

type AllRunningQueriesParams struct {
	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

AllRunningQueriesParams contains all the parameters to send to the API endpoint 

for the all running queries operation.

Typically these are written to a http.Request.

func NewAllRunningQueriesParams 

func NewAllRunningQueriesParams() *AllRunningQueriesParams

NewAllRunningQueriesParams creates a new AllRunningQueriesParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewAllRunningQueriesParamsWithContext 

func NewAllRunningQueriesParamsWithContext(ctx context.Context) *AllRunningQueriesParams

NewAllRunningQueriesParamsWithContext creates a new AllRunningQueriesParams object with the ability to set a context for a request.

func NewAllRunningQueriesParamsWithHTTPClient 

func NewAllRunningQueriesParamsWithHTTPClient(client *http.Client) *AllRunningQueriesParams

NewAllRunningQueriesParamsWithHTTPClient creates a new AllRunningQueriesParams object with the ability to set a custom HTTPClient for a request.

func NewAllRunningQueriesParamsWithTimeout 

func NewAllRunningQueriesParamsWithTimeout(timeout time.Duration) *AllRunningQueriesParams

NewAllRunningQueriesParamsWithTimeout creates a new AllRunningQueriesParams object with the ability to set a timeout on a request.

func (*AllRunningQueriesParams) SetContext 

func (o *AllRunningQueriesParams) SetContext(ctx context.Context)

SetContext adds the context to the all running queries params

func (*AllRunningQueriesParams) SetDefaults 

func (o *AllRunningQueriesParams) SetDefaults()

SetDefaults hydrates default values in the all running queries params (not the query body).

All values with no default are reset to their zero value.

func (*AllRunningQueriesParams) SetHTTPClient 

func (o *AllRunningQueriesParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the all running queries params

func (*AllRunningQueriesParams) SetTimeout 

func (o *AllRunningQueriesParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the all running queries params

func (*AllRunningQueriesParams) WithContext 

func (o *AllRunningQueriesParams) WithContext(ctx context.Context) *AllRunningQueriesParams

WithContext adds the context to the all running queries params

func (*AllRunningQueriesParams) WithDefaults 

func (o *AllRunningQueriesParams) WithDefaults() *AllRunningQueriesParams

WithDefaults hydrates default values in the all running queries params (not the query body).

All values with no default are reset to their zero value.

func (*AllRunningQueriesParams) WithHTTPClient 

func (o *AllRunningQueriesParams) WithHTTPClient(client *http.Client) *AllRunningQueriesParams

WithHTTPClient adds the HTTPClient to the all running queries params

func (*AllRunningQueriesParams) WithTimeout 

func (o *AllRunningQueriesParams) WithTimeout(timeout time.Duration) *AllRunningQueriesParams

WithTimeout adds the timeout to the all running queries params

func (*AllRunningQueriesParams) WriteToRequest 

func (o *AllRunningQueriesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type AllRunningQueriesReader 

type AllRunningQueriesReader struct {
	// contains filtered or unexported fields
}

AllRunningQueriesReader is a Reader for the AllRunningQueries structure.

func (*AllRunningQueriesReader) ReadResponse 

func (o *AllRunningQueriesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client for query API

func (*Client) AllRunningQueries 

func (a *Client) AllRunningQueries(params *AllRunningQueriesParams, opts ...ClientOption) (*AllRunningQueriesOK, error)

AllRunningQueries gets all running queries

Get information about all running queries.

func (*Client) CreateMergeQuery 

func (a *Client) CreateMergeQuery(params *CreateMergeQueryParams, opts ...ClientOption) (*CreateMergeQueryOK, error)
CreateMergeQuery creates merge query

### Create Merge Query

Creates a new merge query object.

A merge query takes the results of one or more queries and combines (merges) the results according to field mapping definitions. The result is similar to a SQL left outer join.

A merge query can merge results of queries from different SQL databases.

The order that queries are defined in the source_queries array property is significant. The first query in the array defines the primary key into which the results of subsequent queries will be merged.

Like model/view query objects, merge queries are immutable and have structural identity - if you make a request to create a new merge query that is identical to an existing merge query, the existing merge query will be returned instead of creating a duplicate. Conversely, any change to the contents of a merge query will produce a new object with a new id.

func (*Client) CreateQuery 

func (a *Client) CreateQuery(params *CreateQueryParams, opts ...ClientOption) (*CreateQueryOK, error)
CreateQuery creates query

### Create a query.

This allows you to create a new query that you can later run. Looker queries are immutable once created and are not deleted. If you create a query that is exactly like an existing query then the existing query will be returned and no new query will be created. Whether a new query is created or not, you can use the 'id' in the returned query with the 'run' method.

The query parameters are passed as json in the body of the request.

func (*Client) CreateQueryTask 

func (a *Client) CreateQueryTask(params *CreateQueryTaskParams, opts ...ClientOption) (*CreateQueryTaskOK, error)
CreateQueryTask runs query async

### Create an async query task

Creates a query task (job) to run a previously created query asynchronously. Returns a Query Task ID.

Use [query_task(query_task_id)](#!/Query/query_task) to check the execution status of the query task. After the query task status reaches "Complete", use [query_task_results(query_task_id)](#!/Query/query_task_results) to fetch the results of the query.

func (*Client) CreateSQLQuery 

func (a *Client) CreateSQLQuery(params *CreateSQLQueryParams, opts ...ClientOption) (*CreateSQLQueryOK, error)
CreateSQLQuery creates SQL runner query

### Create a SQL Runner Query

Either the `connection_name` or `model_name` parameter MUST be provided.

func (*Client) KillQuery 

func (a *Client) KillQuery(params *KillQueryParams, opts ...ClientOption) (*KillQueryNoContent, error)

KillQuery kills running query

Kill a query with a specific query_task_id.

func (*Client) MergeQuery 

func (a *Client) MergeQuery(params *MergeQueryParams, opts ...ClientOption) (*MergeQueryOK, error)
MergeQuery gets merge query

### Get Merge Query

Returns a merge query object given its id.

func (*Client) Query 

func (a *Client) Query(params *QueryParams, opts ...ClientOption) (*QueryOK, error)
Query gets query

### Get a previously created query by id.

A Looker query object includes the various parameters that define a database query that has been run or could be run in the future. These parameters include: model, view, fields, filters, pivots, etc. Query *results* are not part of the query object.

Query objects are unique and immutable. Query objects are created automatically in Looker as users explore data. Looker does not delete them; they become part of the query history. When asked to create a query for any given set of parameters, Looker will first try to find an existing query object with matching parameters and will only create a new object when an appropriate object can not be found.

This 'get' method is used to get the details about a query for a given id. See the other methods here to 'create' and 'run' queries.

Note that some fields like 'filter_config' and 'vis_config' etc are specific to how the Looker UI builds queries and visualizations and are not generally useful for API use. They are not required when creating new queries and can usually just be ignored.

func (*Client) QueryForSlug 

func (a *Client) QueryForSlug(params *QueryForSlugParams, opts ...ClientOption) (*QueryForSlugOK, error)
QueryForSlug gets query for slug

### Get the query for a given query slug.

This returns the query for the 'slug' in a query share URL.

The 'slug' is a randomly chosen short string that is used as an alternative to the query's id value for use in URLs etc. This method exists as a convenience to help you use the API to 'find' queries that have been created using the Looker UI.

You can use the Looker explore page to build a query and then choose the 'Share' option to show the share url for the query. Share urls generally look something like 'https://looker.yourcompany/x/vwGSbfc'. The trailing 'vwGSbfc' is the share slug. You can pass that string to this api method to get details about the query. Those details include the 'id' that you can use to run the query. Or, you can copy the query body (perhaps with your own modification) and use that as the basis to make/run new queries.

This will also work with slugs from Looker explore urls like 'https://looker.yourcompany/explore/ecommerce/orders?qid=aogBgL6o3cKK1jN3RoZl5s'. In this case 'aogBgL6o3cKK1jN3RoZl5s' is the slug.

func (*Client) QueryTask 

func (a *Client) QueryTask(params *QueryTaskParams, opts ...ClientOption) (*QueryTaskOK, error)
QueryTask gets async query info

### Get Query Task details

Use this function to check the status of an async query task. After the status reaches "Complete", you can call [query_task_results(query_task_id)](#!/Query/query_task_results) to retrieve the results of the query.

Use [create_query_task()](#!/Query/create_query_task) to create an async query task.

func (*Client) QueryTaskMultiResults 

func (a *Client) QueryTaskMultiResults(params *QueryTaskMultiResultsParams, opts ...ClientOption) (*QueryTaskMultiResultsOK, error)
QueryTaskMultiResults gets multiple async query results

### Fetch results of multiple async queries

Returns the results of multiple async queries in one request.

For Query Tasks that are not completed, the response will include the execution status of the Query Task but will not include query results. Query Tasks whose results have expired will have a status of 'expired'. If the user making the API request does not have sufficient privileges to view a Query Task result, the result will have a status of 'missing'

func (*Client) QueryTaskResults 

func (a *Client) QueryTaskResults(params *QueryTaskResultsParams, opts ...ClientOption) (*QueryTaskResultsOK, *QueryTaskResultsNoContent, error)
QueryTaskResults gets async query results

### Get Async Query Results

Returns the results of an async query task if the query has completed.

If the query task is still running or waiting to run, this function returns 204 No Content.

If the query task ID is invalid or the cached results of the query task have expired, this function returns 404 Not Found.

Use [query_task(query_task_id)](#!/Query/query_task) to check the execution status of the query task Call query_task_results only after the query task status reaches "Complete".

You can also use [query_task_multi_results()](#!/Query/query_task_multi_results) retrieve the results of multiple async query tasks at the same time.

#### SQL Error Handling: If the query fails due to a SQL db error, how this is communicated depends on the result_format you requested in `create_query_task()`.

For `json_detail` result_format: `query_task_results()` will respond with HTTP status '200 OK' and db SQL error info will be in the `errors` property of the response object. The 'data' property will be empty.

For all other result formats: `query_task_results()` will respond with HTTP status `400 Bad Request` and some db SQL error info will be in the message of the 400 error response, but not as detailed as expressed in `json_detail.errors`. These data formats can only carry row data, and error info is not row data.

func (*Client) RunInlineQuery 

func (a *Client) RunInlineQuery(params *RunInlineQueryParams, opts ...ClientOption) (*RunInlineQueryOK, error)
RunInlineQuery runs inline query

### Run the query that is specified inline in the posted body.

This allows running a query as defined in json in the posted body. This combines the two actions of posting & running a query into one step.

Here is an example body in json: ``` 

{
  "model":"thelook",
  "view":"inventory_items",
  "fields":["category.name","inventory_items.days_in_inventory_tier","products.count"],
  "filters":{"category.name":"socks"},
  "sorts":["products.count desc 0"],
  "limit":"500",
  "query_timezone":"America/Los_Angeles"
}

```

When using the Ruby SDK this would be passed as a Ruby hash like: ``` 

{
 :model=>"thelook",
 :view=>"inventory_items",
 :fields=>
  ["category.name",
   "inventory_items.days_in_inventory_tier",
   "products.count"],
 :filters=>{:"category.name"=>"socks"},
 :sorts=>["products.count desc 0"],
 :limit=>"500",
 :query_timezone=>"America/Los_Angeles",
}

```

This will return the result of running the query in the format specified by the 'result_format' parameter.

Supported formats:

| result_format | Description | :-----------: | :--- | | json | Plain json | json_detail | Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query | csv | Comma separated values with a header | txt | Tab separated values with a header | html | Simple html | md | Simple markdown | xlsx | MS Excel spreadsheet | sql | Returns the generated SQL rather than running the query | png | A PNG image of the visualization of the query | jpg | A JPG image of the visualization of the query

func (*Client) RunQuery 

func (a *Client) RunQuery(params *RunQueryParams, opts ...ClientOption) (*RunQueryOK, error)
RunQuery runs query

### Run a saved query.

This runs a previously saved query. You can use this on a query that was generated in the Looker UI or one that you have explicitly created using the API. You can also use a query 'id' from a saved 'Look'.

The 'result_format' parameter specifies the desired structure and format of the response.

Supported formats:

| result_format | Description | :-----------: | :--- | | json | Plain json | json_detail | Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query | csv | Comma separated values with a header | txt | Tab separated values with a header | html | Simple html | md | Simple markdown | xlsx | MS Excel spreadsheet | sql | Returns the generated SQL rather than running the query | png | A PNG image of the visualization of the query | jpg | A JPG image of the visualization of the query

func (*Client) RunSQLQuery 

func (a *Client) RunSQLQuery(params *RunSQLQueryParams, opts ...ClientOption) (*RunSQLQueryOK, error)

RunSQLQuery runs SQL runner query

Execute a SQL Runner query in a given result_format.

func (*Client) RunURLEncodedQuery 

func (a *Client) RunURLEncodedQuery(params *RunURLEncodedQueryParams, opts ...ClientOption) (*RunURLEncodedQueryOK, error)
RunURLEncodedQuery runs Url encoded query

### Run an URL encoded query.

This requires the caller to encode the specifiers for the query into the URL query part using Looker-specific syntax as explained below.

Generally, you would want to use one of the methods that takes the parameters as json in the POST body for creating and/or running queries. This method exists for cases where one really needs to encode the parameters into the URL of a single 'GET' request. This matches the way that the Looker UI formats 'explore' URLs etc.

The parameters here are very similar to the json body formatting except that the filter syntax is tricky. Unfortunately, this format makes this method not currently callable via the 'Try it out!' button in this documentation page. But, this is callable when creating URLs manually or when using the Looker SDK.

Here is an example inline query URL:

``` https://looker.mycompany.com:19999/api/3.0/queries/models/thelook/views/inventory_items/run/json?fields=category.name,inventory_items.days_in_inventory_tier,products.count&f[category.name]=socks&sorts=products.count+desc+0&limit=500&query_timezone=America/Los_Angeles ```

When invoking this endpoint with the Ruby SDK, pass the query parameter parts as a hash. The hash to match the above would look like:

```ruby query_params = 

{
  :fields => "category.name,inventory_items.days_in_inventory_tier,products.count",
  :"f[category.name]" => "socks",
  :sorts => "products.count desc 0",
  :limit => "500",
  :query_timezone => "America/Los_Angeles"
}

response = ruby_sdk.run_url_encoded_query('thelook','inventory_items','json', query_params)

```

Again, it is generally easier to use the variant of this method that passes the full query in the POST body. This method is available for cases where other alternatives won't fit the need.

Supported formats:

| result_format | Description | :-----------: | :--- | | json | Plain json | json_detail | Row data plus metadata describing the fields, pivots, table calcs, and other aspects of the query | csv | Comma separated values with a header | txt | Tab separated values with a header | html | Simple html | md | Simple markdown | xlsx | MS Excel spreadsheet | sql | Returns the generated SQL rather than running the query | png | A PNG image of the visualization of the query | jpg | A JPG image of the visualization of the query

func (*Client) SQLQuery 

func (a *Client) SQLQuery(params *SQLQueryParams, opts ...ClientOption) (*SQLQueryOK, error)

SQLQuery gets SQL runner query

Get a SQL Runner query.

func (*Client) SetTransport 

func (a *Client) SetTransport(transport runtime.ClientTransport)

SetTransport changes the transport on the client

type ClientOption 

type ClientOption func(*runtime.ClientOperation)

ClientOption is the option for Client methods

type ClientService 

type ClientService interface {
	AllRunningQueries(params *AllRunningQueriesParams, opts ...ClientOption) (*AllRunningQueriesOK, error)

	CreateMergeQuery(params *CreateMergeQueryParams, opts ...ClientOption) (*CreateMergeQueryOK, error)

	CreateQuery(params *CreateQueryParams, opts ...ClientOption) (*CreateQueryOK, error)

	CreateQueryTask(params *CreateQueryTaskParams, opts ...ClientOption) (*CreateQueryTaskOK, error)

	CreateSQLQuery(params *CreateSQLQueryParams, opts ...ClientOption) (*CreateSQLQueryOK, error)

	KillQuery(params *KillQueryParams, opts ...ClientOption) (*KillQueryNoContent, error)

	MergeQuery(params *MergeQueryParams, opts ...ClientOption) (*MergeQueryOK, error)

	Query(params *QueryParams, opts ...ClientOption) (*QueryOK, error)

	QueryForSlug(params *QueryForSlugParams, opts ...ClientOption) (*QueryForSlugOK, error)

	QueryTask(params *QueryTaskParams, opts ...ClientOption) (*QueryTaskOK, error)

	QueryTaskMultiResults(params *QueryTaskMultiResultsParams, opts ...ClientOption) (*QueryTaskMultiResultsOK, error)

	QueryTaskResults(params *QueryTaskResultsParams, opts ...ClientOption) (*QueryTaskResultsOK, *QueryTaskResultsNoContent, error)

	RunInlineQuery(params *RunInlineQueryParams, opts ...ClientOption) (*RunInlineQueryOK, error)

	RunQuery(params *RunQueryParams, opts ...ClientOption) (*RunQueryOK, error)

	RunSQLQuery(params *RunSQLQueryParams, opts ...ClientOption) (*RunSQLQueryOK, error)

	RunURLEncodedQuery(params *RunURLEncodedQueryParams, opts ...ClientOption) (*RunURLEncodedQueryOK, error)

	SQLQuery(params *SQLQueryParams, opts ...ClientOption) (*SQLQueryOK, error)

	SetTransport(transport runtime.ClientTransport)
}

ClientService is the interface for Client methods

func New 

func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService

New creates a new query API client.

type CreateMergeQueryBadRequest 

type CreateMergeQueryBadRequest struct {
	Payload *models.Error
}
CreateMergeQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewCreateMergeQueryBadRequest 

func NewCreateMergeQueryBadRequest() *CreateMergeQueryBadRequest

NewCreateMergeQueryBadRequest creates a CreateMergeQueryBadRequest with default headers values

func (*CreateMergeQueryBadRequest) Error 

func (o *CreateMergeQueryBadRequest) Error() string

func (*CreateMergeQueryBadRequest) GetPayload 

func (o *CreateMergeQueryBadRequest) GetPayload() *models.Error

type CreateMergeQueryConflict 

type CreateMergeQueryConflict struct {
	Payload *models.Error
}
CreateMergeQueryConflict describes a response with status code 409, with default header values.

Resource Already Exists

func NewCreateMergeQueryConflict 

func NewCreateMergeQueryConflict() *CreateMergeQueryConflict

NewCreateMergeQueryConflict creates a CreateMergeQueryConflict with default headers values

func (*CreateMergeQueryConflict) Error 

func (o *CreateMergeQueryConflict) Error() string

func (*CreateMergeQueryConflict) GetPayload 

func (o *CreateMergeQueryConflict) GetPayload() *models.Error

type CreateMergeQueryNotFound 

type CreateMergeQueryNotFound struct {
	Payload *models.Error
}
CreateMergeQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewCreateMergeQueryNotFound 

func NewCreateMergeQueryNotFound() *CreateMergeQueryNotFound

NewCreateMergeQueryNotFound creates a CreateMergeQueryNotFound with default headers values

func (*CreateMergeQueryNotFound) Error 

func (o *CreateMergeQueryNotFound) Error() string

func (*CreateMergeQueryNotFound) GetPayload 

func (o *CreateMergeQueryNotFound) GetPayload() *models.Error

type CreateMergeQueryOK 

type CreateMergeQueryOK struct {
	Payload *models.MergeQuery
}
CreateMergeQueryOK describes a response with status code 200, with default header values.

Merge Query

func NewCreateMergeQueryOK 

func NewCreateMergeQueryOK() *CreateMergeQueryOK

NewCreateMergeQueryOK creates a CreateMergeQueryOK with default headers values

func (*CreateMergeQueryOK) Error 

func (o *CreateMergeQueryOK) Error() string

func (*CreateMergeQueryOK) GetPayload 

func (o *CreateMergeQueryOK) GetPayload() *models.MergeQuery

type CreateMergeQueryParams 

type CreateMergeQueryParams struct {

	/* Body.

	   Merge Query
	*/
	Body *models.MergeQuery

	/* Fields.

	   Requested fields
	*/
	Fields *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

CreateMergeQueryParams contains all the parameters to send to the API endpoint 

for the create merge query operation.

Typically these are written to a http.Request.

func NewCreateMergeQueryParams 

func NewCreateMergeQueryParams() *CreateMergeQueryParams

NewCreateMergeQueryParams creates a new CreateMergeQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewCreateMergeQueryParamsWithContext 

func NewCreateMergeQueryParamsWithContext(ctx context.Context) *CreateMergeQueryParams

NewCreateMergeQueryParamsWithContext creates a new CreateMergeQueryParams object with the ability to set a context for a request.

func NewCreateMergeQueryParamsWithHTTPClient 

func NewCreateMergeQueryParamsWithHTTPClient(client *http.Client) *CreateMergeQueryParams

NewCreateMergeQueryParamsWithHTTPClient creates a new CreateMergeQueryParams object with the ability to set a custom HTTPClient for a request.

func NewCreateMergeQueryParamsWithTimeout 

func NewCreateMergeQueryParamsWithTimeout(timeout time.Duration) *CreateMergeQueryParams

NewCreateMergeQueryParamsWithTimeout creates a new CreateMergeQueryParams object with the ability to set a timeout on a request.

func (*CreateMergeQueryParams) SetBody 

func (o *CreateMergeQueryParams) SetBody(body *models.MergeQuery)

SetBody adds the body to the create merge query params

func (*CreateMergeQueryParams) SetContext 

func (o *CreateMergeQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the create merge query params

func (*CreateMergeQueryParams) SetDefaults 

func (o *CreateMergeQueryParams) SetDefaults()

SetDefaults hydrates default values in the create merge query params (not the query body).

All values with no default are reset to their zero value.

func (*CreateMergeQueryParams) SetFields 

func (o *CreateMergeQueryParams) SetFields(fields *string)

SetFields adds the fields to the create merge query params

func (*CreateMergeQueryParams) SetHTTPClient 

func (o *CreateMergeQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the create merge query params

func (*CreateMergeQueryParams) SetTimeout 

func (o *CreateMergeQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the create merge query params

func (*CreateMergeQueryParams) WithBody 

func (o *CreateMergeQueryParams) WithBody(body *models.MergeQuery) *CreateMergeQueryParams

WithBody adds the body to the create merge query params

func (*CreateMergeQueryParams) WithContext 

func (o *CreateMergeQueryParams) WithContext(ctx context.Context) *CreateMergeQueryParams

WithContext adds the context to the create merge query params

func (*CreateMergeQueryParams) WithDefaults 

func (o *CreateMergeQueryParams) WithDefaults() *CreateMergeQueryParams

WithDefaults hydrates default values in the create merge query params (not the query body).

All values with no default are reset to their zero value.

func (*CreateMergeQueryParams) WithFields 

func (o *CreateMergeQueryParams) WithFields(fields *string) *CreateMergeQueryParams

WithFields adds the fields to the create merge query params

func (*CreateMergeQueryParams) WithHTTPClient 

func (o *CreateMergeQueryParams) WithHTTPClient(client *http.Client) *CreateMergeQueryParams

WithHTTPClient adds the HTTPClient to the create merge query params

func (*CreateMergeQueryParams) WithTimeout 

func (o *CreateMergeQueryParams) WithTimeout(timeout time.Duration) *CreateMergeQueryParams

WithTimeout adds the timeout to the create merge query params

func (*CreateMergeQueryParams) WriteToRequest 

func (o *CreateMergeQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type CreateMergeQueryReader 

type CreateMergeQueryReader struct {
	// contains filtered or unexported fields
}

CreateMergeQueryReader is a Reader for the CreateMergeQuery structure.

func (*CreateMergeQueryReader) ReadResponse 

func (o *CreateMergeQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type CreateMergeQueryTooManyRequests 

type CreateMergeQueryTooManyRequests struct {
	Payload *models.Error
}
CreateMergeQueryTooManyRequests describes a response with status code 429, with default header values.

Too Many Requests

func NewCreateMergeQueryTooManyRequests 

func NewCreateMergeQueryTooManyRequests() *CreateMergeQueryTooManyRequests

NewCreateMergeQueryTooManyRequests creates a CreateMergeQueryTooManyRequests with default headers values

func (*CreateMergeQueryTooManyRequests) Error 

func (o *CreateMergeQueryTooManyRequests) Error() string

func (*CreateMergeQueryTooManyRequests) GetPayload 

func (o *CreateMergeQueryTooManyRequests) GetPayload() *models.Error

type CreateMergeQueryUnprocessableEntity 

type CreateMergeQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}
CreateMergeQueryUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewCreateMergeQueryUnprocessableEntity 

func NewCreateMergeQueryUnprocessableEntity() *CreateMergeQueryUnprocessableEntity

NewCreateMergeQueryUnprocessableEntity creates a CreateMergeQueryUnprocessableEntity with default headers values

func (*CreateMergeQueryUnprocessableEntity) Error 

func (o *CreateMergeQueryUnprocessableEntity) Error() string

func (*CreateMergeQueryUnprocessableEntity) GetPayload 

func (o *CreateMergeQueryUnprocessableEntity) GetPayload() *models.ValidationError

type CreateQueryBadRequest 

type CreateQueryBadRequest struct {
	Payload *models.Error
}
CreateQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewCreateQueryBadRequest 

func NewCreateQueryBadRequest() *CreateQueryBadRequest

NewCreateQueryBadRequest creates a CreateQueryBadRequest with default headers values

func (*CreateQueryBadRequest) Error 

func (o *CreateQueryBadRequest) Error() string

func (*CreateQueryBadRequest) GetPayload 

func (o *CreateQueryBadRequest) GetPayload() *models.Error

type CreateQueryConflict 

type CreateQueryConflict struct {
	Payload *models.Error
}
CreateQueryConflict describes a response with status code 409, with default header values.

Resource Already Exists

func NewCreateQueryConflict 

func NewCreateQueryConflict() *CreateQueryConflict

NewCreateQueryConflict creates a CreateQueryConflict with default headers values

func (*CreateQueryConflict) Error 

func (o *CreateQueryConflict) Error() string

func (*CreateQueryConflict) GetPayload 

func (o *CreateQueryConflict) GetPayload() *models.Error

type CreateQueryNotFound 

type CreateQueryNotFound struct {
	Payload *models.Error
}
CreateQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewCreateQueryNotFound 

func NewCreateQueryNotFound() *CreateQueryNotFound

NewCreateQueryNotFound creates a CreateQueryNotFound with default headers values

func (*CreateQueryNotFound) Error 

func (o *CreateQueryNotFound) Error() string

func (*CreateQueryNotFound) GetPayload 

func (o *CreateQueryNotFound) GetPayload() *models.Error

type CreateQueryOK 

type CreateQueryOK struct {
	Payload *models.Query
}
CreateQueryOK describes a response with status code 200, with default header values.

Query

func NewCreateQueryOK 

func NewCreateQueryOK() *CreateQueryOK

NewCreateQueryOK creates a CreateQueryOK with default headers values

func (*CreateQueryOK) Error 

func (o *CreateQueryOK) Error() string

func (*CreateQueryOK) GetPayload 

func (o *CreateQueryOK) GetPayload() *models.Query

type CreateQueryParams 

type CreateQueryParams struct {

	/* Body.

	   Query
	*/
	Body *models.Query

	/* Fields.

	   Requested fields.
	*/
	Fields *string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

CreateQueryParams contains all the parameters to send to the API endpoint 

for the create query operation.

Typically these are written to a http.Request.

func NewCreateQueryParams 

func NewCreateQueryParams() *CreateQueryParams

NewCreateQueryParams creates a new CreateQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewCreateQueryParamsWithContext 

func NewCreateQueryParamsWithContext(ctx context.Context) *CreateQueryParams

NewCreateQueryParamsWithContext creates a new CreateQueryParams object with the ability to set a context for a request.

func NewCreateQueryParamsWithHTTPClient 

func NewCreateQueryParamsWithHTTPClient(client *http.Client) *CreateQueryParams

NewCreateQueryParamsWithHTTPClient creates a new CreateQueryParams object with the ability to set a custom HTTPClient for a request.

func NewCreateQueryParamsWithTimeout 

func NewCreateQueryParamsWithTimeout(timeout time.Duration) *CreateQueryParams

NewCreateQueryParamsWithTimeout creates a new CreateQueryParams object with the ability to set a timeout on a request.

func (*CreateQueryParams) SetBody 

func (o *CreateQueryParams) SetBody(body *models.Query)

SetBody adds the body to the create query params

func (*CreateQueryParams) SetContext 

func (o *CreateQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the create query params

func (*CreateQueryParams) SetDefaults 

func (o *CreateQueryParams) SetDefaults()

SetDefaults hydrates default values in the create query params (not the query body).

All values with no default are reset to their zero value.

func (*CreateQueryParams) SetFields 

func (o *CreateQueryParams) SetFields(fields *string)

SetFields adds the fields to the create query params

func (*CreateQueryParams) SetHTTPClient 

func (o *CreateQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the create query params

func (*CreateQueryParams) SetTimeout 

func (o *CreateQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the create query params

func (*CreateQueryParams) WithBody 

func (o *CreateQueryParams) WithBody(body *models.Query) *CreateQueryParams

WithBody adds the body to the create query params

func (*CreateQueryParams) WithContext 

func (o *CreateQueryParams) WithContext(ctx context.Context) *CreateQueryParams

WithContext adds the context to the create query params

func (*CreateQueryParams) WithDefaults 

func (o *CreateQueryParams) WithDefaults() *CreateQueryParams

WithDefaults hydrates default values in the create query params (not the query body).

All values with no default are reset to their zero value.

func (*CreateQueryParams) WithFields 

func (o *CreateQueryParams) WithFields(fields *string) *CreateQueryParams

WithFields adds the fields to the create query params

func (*CreateQueryParams) WithHTTPClient 

func (o *CreateQueryParams) WithHTTPClient(client *http.Client) *CreateQueryParams

WithHTTPClient adds the HTTPClient to the create query params

func (*CreateQueryParams) WithTimeout 

func (o *CreateQueryParams) WithTimeout(timeout time.Duration) *CreateQueryParams

WithTimeout adds the timeout to the create query params

func (*CreateQueryParams) WriteToRequest 

func (o *CreateQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type CreateQueryReader 

type CreateQueryReader struct {
	// contains filtered or unexported fields
}

CreateQueryReader is a Reader for the CreateQuery structure.

func (*CreateQueryReader) ReadResponse 

func (o *CreateQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type CreateQueryTaskBadRequest 

type CreateQueryTaskBadRequest struct {
	Payload *models.Error
}
CreateQueryTaskBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewCreateQueryTaskBadRequest 

func NewCreateQueryTaskBadRequest() *CreateQueryTaskBadRequest

NewCreateQueryTaskBadRequest creates a CreateQueryTaskBadRequest with default headers values

func (*CreateQueryTaskBadRequest) Error 

func (o *CreateQueryTaskBadRequest) Error() string

func (*CreateQueryTaskBadRequest) GetPayload 

func (o *CreateQueryTaskBadRequest) GetPayload() *models.Error

type CreateQueryTaskConflict 

type CreateQueryTaskConflict struct {
	Payload *models.Error
}
CreateQueryTaskConflict describes a response with status code 409, with default header values.

Resource Already Exists

func NewCreateQueryTaskConflict 

func NewCreateQueryTaskConflict() *CreateQueryTaskConflict

NewCreateQueryTaskConflict creates a CreateQueryTaskConflict with default headers values

func (*CreateQueryTaskConflict) Error 

func (o *CreateQueryTaskConflict) Error() string

func (*CreateQueryTaskConflict) GetPayload 

func (o *CreateQueryTaskConflict) GetPayload() *models.Error

type CreateQueryTaskNotFound 

type CreateQueryTaskNotFound struct {
	Payload *models.Error
}
CreateQueryTaskNotFound describes a response with status code 404, with default header values.

Not Found

func NewCreateQueryTaskNotFound 

func NewCreateQueryTaskNotFound() *CreateQueryTaskNotFound

NewCreateQueryTaskNotFound creates a CreateQueryTaskNotFound with default headers values

func (*CreateQueryTaskNotFound) Error 

func (o *CreateQueryTaskNotFound) Error() string

func (*CreateQueryTaskNotFound) GetPayload 

func (o *CreateQueryTaskNotFound) GetPayload() *models.Error

type CreateQueryTaskOK 

type CreateQueryTaskOK struct {
	Payload *models.QueryTask
}
CreateQueryTaskOK describes a response with status code 200, with default header values.

query_task

func NewCreateQueryTaskOK 

func NewCreateQueryTaskOK() *CreateQueryTaskOK

NewCreateQueryTaskOK creates a CreateQueryTaskOK with default headers values

func (*CreateQueryTaskOK) Error 

func (o *CreateQueryTaskOK) Error() string

func (*CreateQueryTaskOK) GetPayload 

func (o *CreateQueryTaskOK) GetPayload() *models.QueryTask

type CreateQueryTaskParams 

type CreateQueryTaskParams struct {

	/* ApplyFormatting.

	   Apply model-specified formatting to each result.
	*/
	ApplyFormatting *bool

	/* ApplyVis.

	   Apply visualization options to results.
	*/
	ApplyVis *bool

	/* Body.

	   Query parameters
	*/
	Body *models.CreateQueryTask

	/* Cache.

	   Get results from cache if available.
	*/
	Cache *bool

	/* CacheOnly.

	   Retrieve any results from cache even if the results have expired.
	*/
	CacheOnly *bool

	/* Fields.

	   Requested fields
	*/
	Fields *string

	/* ForceProduction.

	   Force use of production models even if the user is in development mode.
	*/
	ForceProduction *bool

	/* GenerateDrillLinks.

	   Generate drill links (only applicable to 'json_detail' format.
	*/
	GenerateDrillLinks *bool

	/* ImageHeight.

	   Render height for image formats.

	   Format: int64
	*/
	ImageHeight *int64

	/* ImageWidth.

	   Render width for image formats.

	   Format: int64
	*/
	ImageWidth *int64

	/* Limit.

	   Row limit (may override the limit in the saved query).

	   Format: int64
	*/
	Limit *int64

	/* PathPrefix.

	   Prefix to use for drill links (url encoded).
	*/
	PathPrefix *string

	/* RebuildPdts.

	   Rebuild PDTS used in query.
	*/
	RebuildPdts *bool

	/* ServerTableCalcs.

	   Perform table calculations on query results
	*/
	ServerTableCalcs *bool

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

CreateQueryTaskParams contains all the parameters to send to the API endpoint 

for the create query task operation.

Typically these are written to a http.Request.

func NewCreateQueryTaskParams 

func NewCreateQueryTaskParams() *CreateQueryTaskParams

NewCreateQueryTaskParams creates a new CreateQueryTaskParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewCreateQueryTaskParamsWithContext 

func NewCreateQueryTaskParamsWithContext(ctx context.Context) *CreateQueryTaskParams

NewCreateQueryTaskParamsWithContext creates a new CreateQueryTaskParams object with the ability to set a context for a request.

func NewCreateQueryTaskParamsWithHTTPClient 

func NewCreateQueryTaskParamsWithHTTPClient(client *http.Client) *CreateQueryTaskParams

NewCreateQueryTaskParamsWithHTTPClient creates a new CreateQueryTaskParams object with the ability to set a custom HTTPClient for a request.

func NewCreateQueryTaskParamsWithTimeout 

func NewCreateQueryTaskParamsWithTimeout(timeout time.Duration) *CreateQueryTaskParams

NewCreateQueryTaskParamsWithTimeout creates a new CreateQueryTaskParams object with the ability to set a timeout on a request.

func (*CreateQueryTaskParams) SetApplyFormatting 

func (o *CreateQueryTaskParams) SetApplyFormatting(applyFormatting *bool)

SetApplyFormatting adds the applyFormatting to the create query task params

func (*CreateQueryTaskParams) SetApplyVis 

func (o *CreateQueryTaskParams) SetApplyVis(applyVis *bool)

SetApplyVis adds the applyVis to the create query task params

func (*CreateQueryTaskParams) SetBody 

func (o *CreateQueryTaskParams) SetBody(body *models.CreateQueryTask)

SetBody adds the body to the create query task params

func (*CreateQueryTaskParams) SetCache 

func (o *CreateQueryTaskParams) SetCache(cache *bool)

SetCache adds the cache to the create query task params

func (*CreateQueryTaskParams) SetCacheOnly 

func (o *CreateQueryTaskParams) SetCacheOnly(cacheOnly *bool)

SetCacheOnly adds the cacheOnly to the create query task params

func (*CreateQueryTaskParams) SetContext 

func (o *CreateQueryTaskParams) SetContext(ctx context.Context)

SetContext adds the context to the create query task params

func (*CreateQueryTaskParams) SetDefaults 

func (o *CreateQueryTaskParams) SetDefaults()

SetDefaults hydrates default values in the create query task params (not the query body).

All values with no default are reset to their zero value.

func (*CreateQueryTaskParams) SetFields 

func (o *CreateQueryTaskParams) SetFields(fields *string)

SetFields adds the fields to the create query task params

func (*CreateQueryTaskParams) SetForceProduction 

func (o *CreateQueryTaskParams) SetForceProduction(forceProduction *bool)

SetForceProduction adds the forceProduction to the create query task params 

func (o *CreateQueryTaskParams) SetGenerateDrillLinks(generateDrillLinks *bool)

SetGenerateDrillLinks adds the generateDrillLinks to the create query task params

func (*CreateQueryTaskParams) SetHTTPClient 

func (o *CreateQueryTaskParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the create query task params

func (*CreateQueryTaskParams) SetImageHeight 

func (o *CreateQueryTaskParams) SetImageHeight(imageHeight *int64)

SetImageHeight adds the imageHeight to the create query task params

func (*CreateQueryTaskParams) SetImageWidth 

func (o *CreateQueryTaskParams) SetImageWidth(imageWidth *int64)

SetImageWidth adds the imageWidth to the create query task params

func (*CreateQueryTaskParams) SetLimit 

func (o *CreateQueryTaskParams) SetLimit(limit *int64)

SetLimit adds the limit to the create query task params

func (*CreateQueryTaskParams) SetPathPrefix 

func (o *CreateQueryTaskParams) SetPathPrefix(pathPrefix *string)

SetPathPrefix adds the pathPrefix to the create query task params

func (*CreateQueryTaskParams) SetRebuildPdts 

func (o *CreateQueryTaskParams) SetRebuildPdts(rebuildPdts *bool)

SetRebuildPdts adds the rebuildPdts to the create query task params

func (*CreateQueryTaskParams) SetServerTableCalcs 

func (o *CreateQueryTaskParams) SetServerTableCalcs(serverTableCalcs *bool)

SetServerTableCalcs adds the serverTableCalcs to the create query task params

func (*CreateQueryTaskParams) SetTimeout 

func (o *CreateQueryTaskParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the create query task params

func (*CreateQueryTaskParams) WithApplyFormatting 

func (o *CreateQueryTaskParams) WithApplyFormatting(applyFormatting *bool) *CreateQueryTaskParams

WithApplyFormatting adds the applyFormatting to the create query task params

func (*CreateQueryTaskParams) WithApplyVis 

func (o *CreateQueryTaskParams) WithApplyVis(applyVis *bool) *CreateQueryTaskParams

WithApplyVis adds the applyVis to the create query task params

func (*CreateQueryTaskParams) WithBody 

func (o *CreateQueryTaskParams) WithBody(body *models.CreateQueryTask) *CreateQueryTaskParams

WithBody adds the body to the create query task params

func (*CreateQueryTaskParams) WithCache 

func (o *CreateQueryTaskParams) WithCache(cache *bool) *CreateQueryTaskParams

WithCache adds the cache to the create query task params

func (*CreateQueryTaskParams) WithCacheOnly 

func (o *CreateQueryTaskParams) WithCacheOnly(cacheOnly *bool) *CreateQueryTaskParams

WithCacheOnly adds the cacheOnly to the create query task params

func (*CreateQueryTaskParams) WithContext 

func (o *CreateQueryTaskParams) WithContext(ctx context.Context) *CreateQueryTaskParams

WithContext adds the context to the create query task params

func (*CreateQueryTaskParams) WithDefaults 

func (o *CreateQueryTaskParams) WithDefaults() *CreateQueryTaskParams

WithDefaults hydrates default values in the create query task params (not the query body).

All values with no default are reset to their zero value.

func (*CreateQueryTaskParams) WithFields 

func (o *CreateQueryTaskParams) WithFields(fields *string) *CreateQueryTaskParams

WithFields adds the fields to the create query task params

func (*CreateQueryTaskParams) WithForceProduction 

func (o *CreateQueryTaskParams) WithForceProduction(forceProduction *bool) *CreateQueryTaskParams

WithForceProduction adds the forceProduction to the create query task params 

func (o *CreateQueryTaskParams) WithGenerateDrillLinks(generateDrillLinks *bool) *CreateQueryTaskParams

WithGenerateDrillLinks adds the generateDrillLinks to the create query task params

func (*CreateQueryTaskParams) WithHTTPClient 

func (o *CreateQueryTaskParams) WithHTTPClient(client *http.Client) *CreateQueryTaskParams

WithHTTPClient adds the HTTPClient to the create query task params

func (*CreateQueryTaskParams) WithImageHeight 

func (o *CreateQueryTaskParams) WithImageHeight(imageHeight *int64) *CreateQueryTaskParams

WithImageHeight adds the imageHeight to the create query task params

func (*CreateQueryTaskParams) WithImageWidth 

func (o *CreateQueryTaskParams) WithImageWidth(imageWidth *int64) *CreateQueryTaskParams

WithImageWidth adds the imageWidth to the create query task params

func (*CreateQueryTaskParams) WithLimit 

func (o *CreateQueryTaskParams) WithLimit(limit *int64) *CreateQueryTaskParams

WithLimit adds the limit to the create query task params

func (*CreateQueryTaskParams) WithPathPrefix 

func (o *CreateQueryTaskParams) WithPathPrefix(pathPrefix *string) *CreateQueryTaskParams

WithPathPrefix adds the pathPrefix to the create query task params

func (*CreateQueryTaskParams) WithRebuildPdts 

func (o *CreateQueryTaskParams) WithRebuildPdts(rebuildPdts *bool) *CreateQueryTaskParams

WithRebuildPdts adds the rebuildPdts to the create query task params

func (*CreateQueryTaskParams) WithServerTableCalcs 

func (o *CreateQueryTaskParams) WithServerTableCalcs(serverTableCalcs *bool) *CreateQueryTaskParams

WithServerTableCalcs adds the serverTableCalcs to the create query task params

func (*CreateQueryTaskParams) WithTimeout 

func (o *CreateQueryTaskParams) WithTimeout(timeout time.Duration) *CreateQueryTaskParams

WithTimeout adds the timeout to the create query task params

func (*CreateQueryTaskParams) WriteToRequest 

func (o *CreateQueryTaskParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type CreateQueryTaskReader 

type CreateQueryTaskReader struct {
	// contains filtered or unexported fields
}

CreateQueryTaskReader is a Reader for the CreateQueryTask structure.

func (*CreateQueryTaskReader) ReadResponse 

func (o *CreateQueryTaskReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type CreateQueryTaskTooManyRequests 

type CreateQueryTaskTooManyRequests struct {
	Payload *models.Error
}
CreateQueryTaskTooManyRequests describes a response with status code 429, with default header values.

Too Many Requests

func NewCreateQueryTaskTooManyRequests 

func NewCreateQueryTaskTooManyRequests() *CreateQueryTaskTooManyRequests

NewCreateQueryTaskTooManyRequests creates a CreateQueryTaskTooManyRequests with default headers values

func (*CreateQueryTaskTooManyRequests) Error 

func (o *CreateQueryTaskTooManyRequests) Error() string

func (*CreateQueryTaskTooManyRequests) GetPayload 

func (o *CreateQueryTaskTooManyRequests) GetPayload() *models.Error

type CreateQueryTaskUnprocessableEntity 

type CreateQueryTaskUnprocessableEntity struct {
	Payload *models.ValidationError
}
CreateQueryTaskUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewCreateQueryTaskUnprocessableEntity 

func NewCreateQueryTaskUnprocessableEntity() *CreateQueryTaskUnprocessableEntity

NewCreateQueryTaskUnprocessableEntity creates a CreateQueryTaskUnprocessableEntity with default headers values

func (*CreateQueryTaskUnprocessableEntity) Error 

func (o *CreateQueryTaskUnprocessableEntity) Error() string

func (*CreateQueryTaskUnprocessableEntity) GetPayload 

func (o *CreateQueryTaskUnprocessableEntity) GetPayload() *models.ValidationError

type CreateQueryTooManyRequests 

type CreateQueryTooManyRequests struct {
	Payload *models.Error
}
CreateQueryTooManyRequests describes a response with status code 429, with default header values.

Too Many Requests

func NewCreateQueryTooManyRequests 

func NewCreateQueryTooManyRequests() *CreateQueryTooManyRequests

NewCreateQueryTooManyRequests creates a CreateQueryTooManyRequests with default headers values

func (*CreateQueryTooManyRequests) Error 

func (o *CreateQueryTooManyRequests) Error() string

func (*CreateQueryTooManyRequests) GetPayload 

func (o *CreateQueryTooManyRequests) GetPayload() *models.Error

type CreateQueryUnprocessableEntity 

type CreateQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}
CreateQueryUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewCreateQueryUnprocessableEntity 

func NewCreateQueryUnprocessableEntity() *CreateQueryUnprocessableEntity

NewCreateQueryUnprocessableEntity creates a CreateQueryUnprocessableEntity with default headers values

func (*CreateQueryUnprocessableEntity) Error 

func (o *CreateQueryUnprocessableEntity) Error() string

func (*CreateQueryUnprocessableEntity) GetPayload 

func (o *CreateQueryUnprocessableEntity) GetPayload() *models.ValidationError

type CreateSQLQueryBadRequest 

type CreateSQLQueryBadRequest struct {
	Payload *models.Error
}
CreateSQLQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewCreateSQLQueryBadRequest 

func NewCreateSQLQueryBadRequest() *CreateSQLQueryBadRequest

NewCreateSQLQueryBadRequest creates a CreateSQLQueryBadRequest with default headers values

func (*CreateSQLQueryBadRequest) Error 

func (o *CreateSQLQueryBadRequest) Error() string

func (*CreateSQLQueryBadRequest) GetPayload 

func (o *CreateSQLQueryBadRequest) GetPayload() *models.Error

type CreateSQLQueryConflict 

type CreateSQLQueryConflict struct {
	Payload *models.Error
}
CreateSQLQueryConflict describes a response with status code 409, with default header values.

Resource Already Exists

func NewCreateSQLQueryConflict 

func NewCreateSQLQueryConflict() *CreateSQLQueryConflict

NewCreateSQLQueryConflict creates a CreateSQLQueryConflict with default headers values

func (*CreateSQLQueryConflict) Error 

func (o *CreateSQLQueryConflict) Error() string

func (*CreateSQLQueryConflict) GetPayload 

func (o *CreateSQLQueryConflict) GetPayload() *models.Error

type CreateSQLQueryNotFound 

type CreateSQLQueryNotFound struct {
	Payload *models.Error
}
CreateSQLQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewCreateSQLQueryNotFound 

func NewCreateSQLQueryNotFound() *CreateSQLQueryNotFound

NewCreateSQLQueryNotFound creates a CreateSQLQueryNotFound with default headers values

func (*CreateSQLQueryNotFound) Error 

func (o *CreateSQLQueryNotFound) Error() string

func (*CreateSQLQueryNotFound) GetPayload 

func (o *CreateSQLQueryNotFound) GetPayload() *models.Error

type CreateSQLQueryOK 

type CreateSQLQueryOK struct {
	Payload *models.SQLQuery
}
CreateSQLQueryOK describes a response with status code 200, with default header values.

SQL Runner Query

func NewCreateSQLQueryOK 

func NewCreateSQLQueryOK() *CreateSQLQueryOK

NewCreateSQLQueryOK creates a CreateSQLQueryOK with default headers values

func (*CreateSQLQueryOK) Error 

func (o *CreateSQLQueryOK) Error() string

func (*CreateSQLQueryOK) GetPayload 

func (o *CreateSQLQueryOK) GetPayload() *models.SQLQuery

type CreateSQLQueryParams 

type CreateSQLQueryParams struct {

	/* Body.

	   SQL Runner Query
	*/
	Body *models.SQLQueryCreate

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

CreateSQLQueryParams contains all the parameters to send to the API endpoint 

for the create sql query operation.

Typically these are written to a http.Request.

func NewCreateSQLQueryParams 

func NewCreateSQLQueryParams() *CreateSQLQueryParams

NewCreateSQLQueryParams creates a new CreateSQLQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewCreateSQLQueryParamsWithContext 

func NewCreateSQLQueryParamsWithContext(ctx context.Context) *CreateSQLQueryParams

NewCreateSQLQueryParamsWithContext creates a new CreateSQLQueryParams object with the ability to set a context for a request.

func NewCreateSQLQueryParamsWithHTTPClient 

func NewCreateSQLQueryParamsWithHTTPClient(client *http.Client) *CreateSQLQueryParams

NewCreateSQLQueryParamsWithHTTPClient creates a new CreateSQLQueryParams object with the ability to set a custom HTTPClient for a request.

func NewCreateSQLQueryParamsWithTimeout 

func NewCreateSQLQueryParamsWithTimeout(timeout time.Duration) *CreateSQLQueryParams

NewCreateSQLQueryParamsWithTimeout creates a new CreateSQLQueryParams object with the ability to set a timeout on a request.

func (*CreateSQLQueryParams) SetBody 

func (o *CreateSQLQueryParams) SetBody(body *models.SQLQueryCreate)

SetBody adds the body to the create sql query params

func (*CreateSQLQueryParams) SetContext 

func (o *CreateSQLQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the create sql query params

func (*CreateSQLQueryParams) SetDefaults 

func (o *CreateSQLQueryParams) SetDefaults()

SetDefaults hydrates default values in the create sql query params (not the query body).

All values with no default are reset to their zero value.

func (*CreateSQLQueryParams) SetHTTPClient 

func (o *CreateSQLQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the create sql query params

func (*CreateSQLQueryParams) SetTimeout 

func (o *CreateSQLQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the create sql query params

func (*CreateSQLQueryParams) WithBody 

func (o *CreateSQLQueryParams) WithBody(body *models.SQLQueryCreate) *CreateSQLQueryParams

WithBody adds the body to the create sql query params

func (*CreateSQLQueryParams) WithContext 

func (o *CreateSQLQueryParams) WithContext(ctx context.Context) *CreateSQLQueryParams

WithContext adds the context to the create sql query params

func (*CreateSQLQueryParams) WithDefaults 

func (o *CreateSQLQueryParams) WithDefaults() *CreateSQLQueryParams

WithDefaults hydrates default values in the create sql query params (not the query body).

All values with no default are reset to their zero value.

func (*CreateSQLQueryParams) WithHTTPClient 

func (o *CreateSQLQueryParams) WithHTTPClient(client *http.Client) *CreateSQLQueryParams

WithHTTPClient adds the HTTPClient to the create sql query params

func (*CreateSQLQueryParams) WithTimeout 

func (o *CreateSQLQueryParams) WithTimeout(timeout time.Duration) *CreateSQLQueryParams

WithTimeout adds the timeout to the create sql query params

func (*CreateSQLQueryParams) WriteToRequest 

func (o *CreateSQLQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type CreateSQLQueryReader 

type CreateSQLQueryReader struct {
	// contains filtered or unexported fields
}

CreateSQLQueryReader is a Reader for the CreateSQLQuery structure.

func (*CreateSQLQueryReader) ReadResponse 

func (o *CreateSQLQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type CreateSQLQueryTooManyRequests 

type CreateSQLQueryTooManyRequests struct {
	Payload *models.Error
}
CreateSQLQueryTooManyRequests describes a response with status code 429, with default header values.

Too Many Requests

func NewCreateSQLQueryTooManyRequests 

func NewCreateSQLQueryTooManyRequests() *CreateSQLQueryTooManyRequests

NewCreateSQLQueryTooManyRequests creates a CreateSQLQueryTooManyRequests with default headers values

func (*CreateSQLQueryTooManyRequests) Error 

func (o *CreateSQLQueryTooManyRequests) Error() string

func (*CreateSQLQueryTooManyRequests) GetPayload 

func (o *CreateSQLQueryTooManyRequests) GetPayload() *models.Error

type CreateSQLQueryUnprocessableEntity 

type CreateSQLQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}
CreateSQLQueryUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewCreateSQLQueryUnprocessableEntity 

func NewCreateSQLQueryUnprocessableEntity() *CreateSQLQueryUnprocessableEntity

NewCreateSQLQueryUnprocessableEntity creates a CreateSQLQueryUnprocessableEntity with default headers values

func (*CreateSQLQueryUnprocessableEntity) Error 

func (o *CreateSQLQueryUnprocessableEntity) Error() string

func (*CreateSQLQueryUnprocessableEntity) GetPayload 

func (o *CreateSQLQueryUnprocessableEntity) GetPayload() *models.ValidationError

type KillQueryBadRequest 

type KillQueryBadRequest struct {
	Payload *models.Error
}
KillQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewKillQueryBadRequest 

func NewKillQueryBadRequest() *KillQueryBadRequest

NewKillQueryBadRequest creates a KillQueryBadRequest with default headers values

func (*KillQueryBadRequest) Error 

func (o *KillQueryBadRequest) Error() string

func (*KillQueryBadRequest) GetPayload 

func (o *KillQueryBadRequest) GetPayload() *models.Error

type KillQueryNoContent 

type KillQueryNoContent struct {
	Payload string
}
KillQueryNoContent describes a response with status code 204, with default header values.

Query successfully killed.

func NewKillQueryNoContent 

func NewKillQueryNoContent() *KillQueryNoContent

NewKillQueryNoContent creates a KillQueryNoContent with default headers values

func (*KillQueryNoContent) Error 

func (o *KillQueryNoContent) Error() string

func (*KillQueryNoContent) GetPayload 

func (o *KillQueryNoContent) GetPayload() string

type KillQueryNotFound 

type KillQueryNotFound struct {
	Payload *models.Error
}
KillQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewKillQueryNotFound 

func NewKillQueryNotFound() *KillQueryNotFound

NewKillQueryNotFound creates a KillQueryNotFound with default headers values

func (*KillQueryNotFound) Error 

func (o *KillQueryNotFound) Error() string

func (*KillQueryNotFound) GetPayload 

func (o *KillQueryNotFound) GetPayload() *models.Error

type KillQueryParams 

type KillQueryParams struct {

	/* QueryTaskID.

	   Query task id.
	*/
	QueryTaskID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

KillQueryParams contains all the parameters to send to the API endpoint 

for the kill query operation.

Typically these are written to a http.Request.

func NewKillQueryParams 

func NewKillQueryParams() *KillQueryParams

NewKillQueryParams creates a new KillQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewKillQueryParamsWithContext 

func NewKillQueryParamsWithContext(ctx context.Context) *KillQueryParams

NewKillQueryParamsWithContext creates a new KillQueryParams object with the ability to set a context for a request.

func NewKillQueryParamsWithHTTPClient 

func NewKillQueryParamsWithHTTPClient(client *http.Client) *KillQueryParams

NewKillQueryParamsWithHTTPClient creates a new KillQueryParams object with the ability to set a custom HTTPClient for a request.

func NewKillQueryParamsWithTimeout 

func NewKillQueryParamsWithTimeout(timeout time.Duration) *KillQueryParams

NewKillQueryParamsWithTimeout creates a new KillQueryParams object with the ability to set a timeout on a request.

func (*KillQueryParams) SetContext 

func (o *KillQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the kill query params

func (*KillQueryParams) SetDefaults 

func (o *KillQueryParams) SetDefaults()

SetDefaults hydrates default values in the kill query params (not the query body).

All values with no default are reset to their zero value.

func (*KillQueryParams) SetHTTPClient 

func (o *KillQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the kill query params

func (*KillQueryParams) SetQueryTaskID 

func (o *KillQueryParams) SetQueryTaskID(queryTaskID string)

SetQueryTaskID adds the queryTaskId to the kill query params

func (*KillQueryParams) SetTimeout 

func (o *KillQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the kill query params

func (*KillQueryParams) WithContext 

func (o *KillQueryParams) WithContext(ctx context.Context) *KillQueryParams

WithContext adds the context to the kill query params

func (*KillQueryParams) WithDefaults 

func (o *KillQueryParams) WithDefaults() *KillQueryParams

WithDefaults hydrates default values in the kill query params (not the query body).

All values with no default are reset to their zero value.

func (*KillQueryParams) WithHTTPClient 

func (o *KillQueryParams) WithHTTPClient(client *http.Client) *KillQueryParams

WithHTTPClient adds the HTTPClient to the kill query params

func (*KillQueryParams) WithQueryTaskID 

func (o *KillQueryParams) WithQueryTaskID(queryTaskID string) *KillQueryParams

WithQueryTaskID adds the queryTaskID to the kill query params

func (*KillQueryParams) WithTimeout 

func (o *KillQueryParams) WithTimeout(timeout time.Duration) *KillQueryParams

WithTimeout adds the timeout to the kill query params

func (*KillQueryParams) WriteToRequest 

func (o *KillQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type KillQueryReader 

type KillQueryReader struct {
	// contains filtered or unexported fields
}

KillQueryReader is a Reader for the KillQuery structure.

func (*KillQueryReader) ReadResponse 

func (o *KillQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type KillQueryUnprocessableEntity 

type KillQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}
KillQueryUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewKillQueryUnprocessableEntity 

func NewKillQueryUnprocessableEntity() *KillQueryUnprocessableEntity

NewKillQueryUnprocessableEntity creates a KillQueryUnprocessableEntity with default headers values

func (*KillQueryUnprocessableEntity) Error 

func (o *KillQueryUnprocessableEntity) Error() string

func (*KillQueryUnprocessableEntity) GetPayload 

func (o *KillQueryUnprocessableEntity) GetPayload() *models.ValidationError

type MergeQueryBadRequest 

type MergeQueryBadRequest struct {
	Payload *models.Error
}
MergeQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewMergeQueryBadRequest 

func NewMergeQueryBadRequest() *MergeQueryBadRequest

NewMergeQueryBadRequest creates a MergeQueryBadRequest with default headers values

func (*MergeQueryBadRequest) Error 

func (o *MergeQueryBadRequest) Error() string

func (*MergeQueryBadRequest) GetPayload 

func (o *MergeQueryBadRequest) GetPayload() *models.Error

type MergeQueryNotFound 

type MergeQueryNotFound struct {
	Payload *models.Error
}
MergeQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewMergeQueryNotFound 

func NewMergeQueryNotFound() *MergeQueryNotFound

NewMergeQueryNotFound creates a MergeQueryNotFound with default headers values

func (*MergeQueryNotFound) Error 

func (o *MergeQueryNotFound) Error() string

func (*MergeQueryNotFound) GetPayload 

func (o *MergeQueryNotFound) GetPayload() *models.Error

type MergeQueryOK 

type MergeQueryOK struct {
	Payload *models.MergeQuery
}
MergeQueryOK describes a response with status code 200, with default header values.

Merge Query

func NewMergeQueryOK 

func NewMergeQueryOK() *MergeQueryOK

NewMergeQueryOK creates a MergeQueryOK with default headers values

func (*MergeQueryOK) Error 

func (o *MergeQueryOK) Error() string

func (*MergeQueryOK) GetPayload 

func (o *MergeQueryOK) GetPayload() *models.MergeQuery

type MergeQueryParams 

type MergeQueryParams struct {

	/* Fields.

	   Requested fields
	*/
	Fields *string

	/* MergeQueryID.

	   Merge Query Id
	*/
	MergeQueryID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

MergeQueryParams contains all the parameters to send to the API endpoint 

for the merge query operation.

Typically these are written to a http.Request.

func NewMergeQueryParams 

func NewMergeQueryParams() *MergeQueryParams

NewMergeQueryParams creates a new MergeQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewMergeQueryParamsWithContext 

func NewMergeQueryParamsWithContext(ctx context.Context) *MergeQueryParams

NewMergeQueryParamsWithContext creates a new MergeQueryParams object with the ability to set a context for a request.

func NewMergeQueryParamsWithHTTPClient 

func NewMergeQueryParamsWithHTTPClient(client *http.Client) *MergeQueryParams

NewMergeQueryParamsWithHTTPClient creates a new MergeQueryParams object with the ability to set a custom HTTPClient for a request.

func NewMergeQueryParamsWithTimeout 

func NewMergeQueryParamsWithTimeout(timeout time.Duration) *MergeQueryParams

NewMergeQueryParamsWithTimeout creates a new MergeQueryParams object with the ability to set a timeout on a request.

func (*MergeQueryParams) SetContext 

func (o *MergeQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the merge query params

func (*MergeQueryParams) SetDefaults 

func (o *MergeQueryParams) SetDefaults()

SetDefaults hydrates default values in the merge query params (not the query body).

All values with no default are reset to their zero value.

func (*MergeQueryParams) SetFields 

func (o *MergeQueryParams) SetFields(fields *string)

SetFields adds the fields to the merge query params

func (*MergeQueryParams) SetHTTPClient 

func (o *MergeQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the merge query params

func (*MergeQueryParams) SetMergeQueryID 

func (o *MergeQueryParams) SetMergeQueryID(mergeQueryID string)

SetMergeQueryID adds the mergeQueryId to the merge query params

func (*MergeQueryParams) SetTimeout 

func (o *MergeQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the merge query params

func (*MergeQueryParams) WithContext 

func (o *MergeQueryParams) WithContext(ctx context.Context) *MergeQueryParams

WithContext adds the context to the merge query params

func (*MergeQueryParams) WithDefaults 

func (o *MergeQueryParams) WithDefaults() *MergeQueryParams

WithDefaults hydrates default values in the merge query params (not the query body).

All values with no default are reset to their zero value.

func (*MergeQueryParams) WithFields 

func (o *MergeQueryParams) WithFields(fields *string) *MergeQueryParams

WithFields adds the fields to the merge query params

func (*MergeQueryParams) WithHTTPClient 

func (o *MergeQueryParams) WithHTTPClient(client *http.Client) *MergeQueryParams

WithHTTPClient adds the HTTPClient to the merge query params

func (*MergeQueryParams) WithMergeQueryID 

func (o *MergeQueryParams) WithMergeQueryID(mergeQueryID string) *MergeQueryParams

WithMergeQueryID adds the mergeQueryID to the merge query params

func (*MergeQueryParams) WithTimeout 

func (o *MergeQueryParams) WithTimeout(timeout time.Duration) *MergeQueryParams

WithTimeout adds the timeout to the merge query params

func (*MergeQueryParams) WriteToRequest 

func (o *MergeQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type MergeQueryReader 

type MergeQueryReader struct {
	// contains filtered or unexported fields
}

MergeQueryReader is a Reader for the MergeQuery structure.

func (*MergeQueryReader) ReadResponse 

func (o *MergeQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type QueryBadRequest 

type QueryBadRequest struct {
	Payload *models.Error
}
QueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewQueryBadRequest 

func NewQueryBadRequest() *QueryBadRequest

NewQueryBadRequest creates a QueryBadRequest with default headers values

func (*QueryBadRequest) Error 

func (o *QueryBadRequest) Error() string

func (*QueryBadRequest) GetPayload 

func (o *QueryBadRequest) GetPayload() *models.Error

type QueryForSlugBadRequest 

type QueryForSlugBadRequest struct {
	Payload *models.Error
}
QueryForSlugBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewQueryForSlugBadRequest 

func NewQueryForSlugBadRequest() *QueryForSlugBadRequest

NewQueryForSlugBadRequest creates a QueryForSlugBadRequest with default headers values

func (*QueryForSlugBadRequest) Error 

func (o *QueryForSlugBadRequest) Error() string

func (*QueryForSlugBadRequest) GetPayload 

func (o *QueryForSlugBadRequest) GetPayload() *models.Error

type QueryForSlugNotFound 

type QueryForSlugNotFound struct {
	Payload *models.Error
}
QueryForSlugNotFound describes a response with status code 404, with default header values.

Not Found

func NewQueryForSlugNotFound 

func NewQueryForSlugNotFound() *QueryForSlugNotFound

NewQueryForSlugNotFound creates a QueryForSlugNotFound with default headers values

func (*QueryForSlugNotFound) Error 

func (o *QueryForSlugNotFound) Error() string

func (*QueryForSlugNotFound) GetPayload 

func (o *QueryForSlugNotFound) GetPayload() *models.Error

type QueryForSlugOK 

type QueryForSlugOK struct {
	Payload *models.Query
}
QueryForSlugOK describes a response with status code 200, with default header values.

Query

func NewQueryForSlugOK 

func NewQueryForSlugOK() *QueryForSlugOK

NewQueryForSlugOK creates a QueryForSlugOK with default headers values

func (*QueryForSlugOK) Error 

func (o *QueryForSlugOK) Error() string

func (*QueryForSlugOK) GetPayload 

func (o *QueryForSlugOK) GetPayload() *models.Query

type QueryForSlugParams 

type QueryForSlugParams struct {

	/* Fields.

	   Requested fields.
	*/
	Fields *string

	/* Slug.

	   Slug of query
	*/
	Slug string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

QueryForSlugParams contains all the parameters to send to the API endpoint 

for the query for slug operation.

Typically these are written to a http.Request.

func NewQueryForSlugParams 

func NewQueryForSlugParams() *QueryForSlugParams

NewQueryForSlugParams creates a new QueryForSlugParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewQueryForSlugParamsWithContext 

func NewQueryForSlugParamsWithContext(ctx context.Context) *QueryForSlugParams

NewQueryForSlugParamsWithContext creates a new QueryForSlugParams object with the ability to set a context for a request.

func NewQueryForSlugParamsWithHTTPClient 

func NewQueryForSlugParamsWithHTTPClient(client *http.Client) *QueryForSlugParams

NewQueryForSlugParamsWithHTTPClient creates a new QueryForSlugParams object with the ability to set a custom HTTPClient for a request.

func NewQueryForSlugParamsWithTimeout 

func NewQueryForSlugParamsWithTimeout(timeout time.Duration) *QueryForSlugParams

NewQueryForSlugParamsWithTimeout creates a new QueryForSlugParams object with the ability to set a timeout on a request.

func (*QueryForSlugParams) SetContext 

func (o *QueryForSlugParams) SetContext(ctx context.Context)

SetContext adds the context to the query for slug params

func (*QueryForSlugParams) SetDefaults 

func (o *QueryForSlugParams) SetDefaults()

SetDefaults hydrates default values in the query for slug params (not the query body).

All values with no default are reset to their zero value.

func (*QueryForSlugParams) SetFields 

func (o *QueryForSlugParams) SetFields(fields *string)

SetFields adds the fields to the query for slug params

func (*QueryForSlugParams) SetHTTPClient 

func (o *QueryForSlugParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the query for slug params

func (*QueryForSlugParams) SetSlug 

func (o *QueryForSlugParams) SetSlug(slug string)

SetSlug adds the slug to the query for slug params

func (*QueryForSlugParams) SetTimeout 

func (o *QueryForSlugParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the query for slug params

func (*QueryForSlugParams) WithContext 

func (o *QueryForSlugParams) WithContext(ctx context.Context) *QueryForSlugParams

WithContext adds the context to the query for slug params

func (*QueryForSlugParams) WithDefaults 

func (o *QueryForSlugParams) WithDefaults() *QueryForSlugParams

WithDefaults hydrates default values in the query for slug params (not the query body).

All values with no default are reset to their zero value.

func (*QueryForSlugParams) WithFields 

func (o *QueryForSlugParams) WithFields(fields *string) *QueryForSlugParams

WithFields adds the fields to the query for slug params

func (*QueryForSlugParams) WithHTTPClient 

func (o *QueryForSlugParams) WithHTTPClient(client *http.Client) *QueryForSlugParams

WithHTTPClient adds the HTTPClient to the query for slug params

func (*QueryForSlugParams) WithSlug 

func (o *QueryForSlugParams) WithSlug(slug string) *QueryForSlugParams

WithSlug adds the slug to the query for slug params

func (*QueryForSlugParams) WithTimeout 

func (o *QueryForSlugParams) WithTimeout(timeout time.Duration) *QueryForSlugParams

WithTimeout adds the timeout to the query for slug params

func (*QueryForSlugParams) WriteToRequest 

func (o *QueryForSlugParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type QueryForSlugReader 

type QueryForSlugReader struct {
	// contains filtered or unexported fields
}

QueryForSlugReader is a Reader for the QueryForSlug structure.

func (*QueryForSlugReader) ReadResponse 

func (o *QueryForSlugReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type QueryNotFound 

type QueryNotFound struct {
	Payload *models.Error
}
QueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewQueryNotFound 

func NewQueryNotFound() *QueryNotFound

NewQueryNotFound creates a QueryNotFound with default headers values

func (*QueryNotFound) Error 

func (o *QueryNotFound) Error() string

func (*QueryNotFound) GetPayload 

func (o *QueryNotFound) GetPayload() *models.Error

type QueryOK 

type QueryOK struct {
	Payload *models.Query
}
QueryOK describes a response with status code 200, with default header values.

Query

func NewQueryOK 

func NewQueryOK() *QueryOK

NewQueryOK creates a QueryOK with default headers values

func (*QueryOK) Error 

func (o *QueryOK) Error() string

func (*QueryOK) GetPayload 

func (o *QueryOK) GetPayload() *models.Query

type QueryParams 

type QueryParams struct {

	/* Fields.

	   Requested fields.
	*/
	Fields *string

	/* QueryID.

	   Id of query

	   Format: int64
	*/
	QueryID int64

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

QueryParams contains all the parameters to send to the API endpoint 

for the query operation.

Typically these are written to a http.Request.

func NewQueryParams 

func NewQueryParams() *QueryParams

NewQueryParams creates a new QueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewQueryParamsWithContext 

func NewQueryParamsWithContext(ctx context.Context) *QueryParams

NewQueryParamsWithContext creates a new QueryParams object with the ability to set a context for a request.

func NewQueryParamsWithHTTPClient 

func NewQueryParamsWithHTTPClient(client *http.Client) *QueryParams

NewQueryParamsWithHTTPClient creates a new QueryParams object with the ability to set a custom HTTPClient for a request.

func NewQueryParamsWithTimeout 

func NewQueryParamsWithTimeout(timeout time.Duration) *QueryParams

NewQueryParamsWithTimeout creates a new QueryParams object with the ability to set a timeout on a request.

func (*QueryParams) SetContext 

func (o *QueryParams) SetContext(ctx context.Context)

SetContext adds the context to the query params

func (*QueryParams) SetDefaults 

func (o *QueryParams) SetDefaults()

SetDefaults hydrates default values in the query params (not the query body).

All values with no default are reset to their zero value.

func (*QueryParams) SetFields 

func (o *QueryParams) SetFields(fields *string)

SetFields adds the fields to the query params

func (*QueryParams) SetHTTPClient 

func (o *QueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the query params

func (*QueryParams) SetQueryID 

func (o *QueryParams) SetQueryID(queryID int64)

SetQueryID adds the queryId to the query params

func (*QueryParams) SetTimeout 

func (o *QueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the query params

func (*QueryParams) WithContext 

func (o *QueryParams) WithContext(ctx context.Context) *QueryParams

WithContext adds the context to the query params

func (*QueryParams) WithDefaults 

func (o *QueryParams) WithDefaults() *QueryParams

WithDefaults hydrates default values in the query params (not the query body).

All values with no default are reset to their zero value.

func (*QueryParams) WithFields 

func (o *QueryParams) WithFields(fields *string) *QueryParams

WithFields adds the fields to the query params

func (*QueryParams) WithHTTPClient 

func (o *QueryParams) WithHTTPClient(client *http.Client) *QueryParams

WithHTTPClient adds the HTTPClient to the query params

func (*QueryParams) WithQueryID 

func (o *QueryParams) WithQueryID(queryID int64) *QueryParams

WithQueryID adds the queryID to the query params

func (*QueryParams) WithTimeout 

func (o *QueryParams) WithTimeout(timeout time.Duration) *QueryParams

WithTimeout adds the timeout to the query params

func (*QueryParams) WriteToRequest 

func (o *QueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type QueryReader 

type QueryReader struct {
	// contains filtered or unexported fields
}

QueryReader is a Reader for the Query structure.

func (*QueryReader) ReadResponse 

func (o *QueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type QueryTaskBadRequest 

type QueryTaskBadRequest struct {
	Payload *models.Error
}
QueryTaskBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewQueryTaskBadRequest 

func NewQueryTaskBadRequest() *QueryTaskBadRequest

NewQueryTaskBadRequest creates a QueryTaskBadRequest with default headers values

func (*QueryTaskBadRequest) Error 

func (o *QueryTaskBadRequest) Error() string

func (*QueryTaskBadRequest) GetPayload 

func (o *QueryTaskBadRequest) GetPayload() *models.Error

type QueryTaskMultiResultsBadRequest 

type QueryTaskMultiResultsBadRequest struct {
	Payload *models.Error
}
QueryTaskMultiResultsBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewQueryTaskMultiResultsBadRequest 

func NewQueryTaskMultiResultsBadRequest() *QueryTaskMultiResultsBadRequest

NewQueryTaskMultiResultsBadRequest creates a QueryTaskMultiResultsBadRequest with default headers values

func (*QueryTaskMultiResultsBadRequest) Error 

func (o *QueryTaskMultiResultsBadRequest) Error() string

func (*QueryTaskMultiResultsBadRequest) GetPayload 

func (o *QueryTaskMultiResultsBadRequest) GetPayload() *models.Error

type QueryTaskMultiResultsNotFound 

type QueryTaskMultiResultsNotFound struct {
	Payload *models.Error
}
QueryTaskMultiResultsNotFound describes a response with status code 404, with default header values.

Not Found

func NewQueryTaskMultiResultsNotFound 

func NewQueryTaskMultiResultsNotFound() *QueryTaskMultiResultsNotFound

NewQueryTaskMultiResultsNotFound creates a QueryTaskMultiResultsNotFound with default headers values

func (*QueryTaskMultiResultsNotFound) Error 

func (o *QueryTaskMultiResultsNotFound) Error() string

func (*QueryTaskMultiResultsNotFound) GetPayload 

func (o *QueryTaskMultiResultsNotFound) GetPayload() *models.Error

type QueryTaskMultiResultsOK 

type QueryTaskMultiResultsOK struct {
	Payload map[string]string
}
QueryTaskMultiResultsOK describes a response with status code 200, with default header values.

Multiple query results

func NewQueryTaskMultiResultsOK 

func NewQueryTaskMultiResultsOK() *QueryTaskMultiResultsOK

NewQueryTaskMultiResultsOK creates a QueryTaskMultiResultsOK with default headers values

func (*QueryTaskMultiResultsOK) Error 

func (o *QueryTaskMultiResultsOK) Error() string

func (*QueryTaskMultiResultsOK) GetPayload 

func (o *QueryTaskMultiResultsOK) GetPayload() map[string]string

type QueryTaskMultiResultsParams 

type QueryTaskMultiResultsParams struct {

	/* QueryTaskIds.

	   List of Query Task IDs
	*/
	QueryTaskIds []string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

QueryTaskMultiResultsParams contains all the parameters to send to the API endpoint 

for the query task multi results operation.

Typically these are written to a http.Request.

func NewQueryTaskMultiResultsParams 

func NewQueryTaskMultiResultsParams() *QueryTaskMultiResultsParams

NewQueryTaskMultiResultsParams creates a new QueryTaskMultiResultsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewQueryTaskMultiResultsParamsWithContext 

func NewQueryTaskMultiResultsParamsWithContext(ctx context.Context) *QueryTaskMultiResultsParams

NewQueryTaskMultiResultsParamsWithContext creates a new QueryTaskMultiResultsParams object with the ability to set a context for a request.

func NewQueryTaskMultiResultsParamsWithHTTPClient 

func NewQueryTaskMultiResultsParamsWithHTTPClient(client *http.Client) *QueryTaskMultiResultsParams

NewQueryTaskMultiResultsParamsWithHTTPClient creates a new QueryTaskMultiResultsParams object with the ability to set a custom HTTPClient for a request.

func NewQueryTaskMultiResultsParamsWithTimeout 

func NewQueryTaskMultiResultsParamsWithTimeout(timeout time.Duration) *QueryTaskMultiResultsParams

NewQueryTaskMultiResultsParamsWithTimeout creates a new QueryTaskMultiResultsParams object with the ability to set a timeout on a request.

func (*QueryTaskMultiResultsParams) SetContext 

func (o *QueryTaskMultiResultsParams) SetContext(ctx context.Context)

SetContext adds the context to the query task multi results params

func (*QueryTaskMultiResultsParams) SetDefaults 

func (o *QueryTaskMultiResultsParams) SetDefaults()

SetDefaults hydrates default values in the query task multi results params (not the query body).

All values with no default are reset to their zero value.

func (*QueryTaskMultiResultsParams) SetHTTPClient 

func (o *QueryTaskMultiResultsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the query task multi results params

func (*QueryTaskMultiResultsParams) SetQueryTaskIds 

func (o *QueryTaskMultiResultsParams) SetQueryTaskIds(queryTaskIds []string)

SetQueryTaskIds adds the queryTaskIds to the query task multi results params

func (*QueryTaskMultiResultsParams) SetTimeout 

func (o *QueryTaskMultiResultsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the query task multi results params

func (*QueryTaskMultiResultsParams) WithContext 

func (o *QueryTaskMultiResultsParams) WithContext(ctx context.Context) *QueryTaskMultiResultsParams

WithContext adds the context to the query task multi results params

func (*QueryTaskMultiResultsParams) WithDefaults 

func (o *QueryTaskMultiResultsParams) WithDefaults() *QueryTaskMultiResultsParams

WithDefaults hydrates default values in the query task multi results params (not the query body).

All values with no default are reset to their zero value.

func (*QueryTaskMultiResultsParams) WithHTTPClient 

func (o *QueryTaskMultiResultsParams) WithHTTPClient(client *http.Client) *QueryTaskMultiResultsParams

WithHTTPClient adds the HTTPClient to the query task multi results params

func (*QueryTaskMultiResultsParams) WithQueryTaskIds 

func (o *QueryTaskMultiResultsParams) WithQueryTaskIds(queryTaskIds []string) *QueryTaskMultiResultsParams

WithQueryTaskIds adds the queryTaskIds to the query task multi results params

func (*QueryTaskMultiResultsParams) WithTimeout 

func (o *QueryTaskMultiResultsParams) WithTimeout(timeout time.Duration) *QueryTaskMultiResultsParams

WithTimeout adds the timeout to the query task multi results params

func (*QueryTaskMultiResultsParams) WriteToRequest 

func (o *QueryTaskMultiResultsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type QueryTaskMultiResultsReader 

type QueryTaskMultiResultsReader struct {
	// contains filtered or unexported fields
}

QueryTaskMultiResultsReader is a Reader for the QueryTaskMultiResults structure.

func (*QueryTaskMultiResultsReader) ReadResponse 

func (o *QueryTaskMultiResultsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type QueryTaskNotFound 

type QueryTaskNotFound struct {
	Payload *models.Error
}
QueryTaskNotFound describes a response with status code 404, with default header values.

Not Found

func NewQueryTaskNotFound 

func NewQueryTaskNotFound() *QueryTaskNotFound

NewQueryTaskNotFound creates a QueryTaskNotFound with default headers values

func (*QueryTaskNotFound) Error 

func (o *QueryTaskNotFound) Error() string

func (*QueryTaskNotFound) GetPayload 

func (o *QueryTaskNotFound) GetPayload() *models.Error

type QueryTaskOK 

type QueryTaskOK struct {
	Payload *models.QueryTask
}
QueryTaskOK describes a response with status code 200, with default header values.

query_task

func NewQueryTaskOK 

func NewQueryTaskOK() *QueryTaskOK

NewQueryTaskOK creates a QueryTaskOK with default headers values

func (*QueryTaskOK) Error 

func (o *QueryTaskOK) Error() string

func (*QueryTaskOK) GetPayload 

func (o *QueryTaskOK) GetPayload() *models.QueryTask

type QueryTaskParams 

type QueryTaskParams struct {

	/* Fields.

	   Requested fields.
	*/
	Fields *string

	/* QueryTaskID.

	   ID of the Query Task
	*/
	QueryTaskID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

QueryTaskParams contains all the parameters to send to the API endpoint 

for the query task operation.

Typically these are written to a http.Request.

func NewQueryTaskParams 

func NewQueryTaskParams() *QueryTaskParams

NewQueryTaskParams creates a new QueryTaskParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewQueryTaskParamsWithContext 

func NewQueryTaskParamsWithContext(ctx context.Context) *QueryTaskParams

NewQueryTaskParamsWithContext creates a new QueryTaskParams object with the ability to set a context for a request.

func NewQueryTaskParamsWithHTTPClient 

func NewQueryTaskParamsWithHTTPClient(client *http.Client) *QueryTaskParams

NewQueryTaskParamsWithHTTPClient creates a new QueryTaskParams object with the ability to set a custom HTTPClient for a request.

func NewQueryTaskParamsWithTimeout 

func NewQueryTaskParamsWithTimeout(timeout time.Duration) *QueryTaskParams

NewQueryTaskParamsWithTimeout creates a new QueryTaskParams object with the ability to set a timeout on a request.

func (*QueryTaskParams) SetContext 

func (o *QueryTaskParams) SetContext(ctx context.Context)

SetContext adds the context to the query task params

func (*QueryTaskParams) SetDefaults 

func (o *QueryTaskParams) SetDefaults()

SetDefaults hydrates default values in the query task params (not the query body).

All values with no default are reset to their zero value.

func (*QueryTaskParams) SetFields 

func (o *QueryTaskParams) SetFields(fields *string)

SetFields adds the fields to the query task params

func (*QueryTaskParams) SetHTTPClient 

func (o *QueryTaskParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the query task params

func (*QueryTaskParams) SetQueryTaskID 

func (o *QueryTaskParams) SetQueryTaskID(queryTaskID string)

SetQueryTaskID adds the queryTaskId to the query task params

func (*QueryTaskParams) SetTimeout 

func (o *QueryTaskParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the query task params

func (*QueryTaskParams) WithContext 

func (o *QueryTaskParams) WithContext(ctx context.Context) *QueryTaskParams

WithContext adds the context to the query task params

func (*QueryTaskParams) WithDefaults 

func (o *QueryTaskParams) WithDefaults() *QueryTaskParams

WithDefaults hydrates default values in the query task params (not the query body).

All values with no default are reset to their zero value.

func (*QueryTaskParams) WithFields 

func (o *QueryTaskParams) WithFields(fields *string) *QueryTaskParams

WithFields adds the fields to the query task params

func (*QueryTaskParams) WithHTTPClient 

func (o *QueryTaskParams) WithHTTPClient(client *http.Client) *QueryTaskParams

WithHTTPClient adds the HTTPClient to the query task params

func (*QueryTaskParams) WithQueryTaskID 

func (o *QueryTaskParams) WithQueryTaskID(queryTaskID string) *QueryTaskParams

WithQueryTaskID adds the queryTaskID to the query task params

func (*QueryTaskParams) WithTimeout 

func (o *QueryTaskParams) WithTimeout(timeout time.Duration) *QueryTaskParams

WithTimeout adds the timeout to the query task params

func (*QueryTaskParams) WriteToRequest 

func (o *QueryTaskParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type QueryTaskReader 

type QueryTaskReader struct {
	// contains filtered or unexported fields
}

QueryTaskReader is a Reader for the QueryTask structure.

func (*QueryTaskReader) ReadResponse 

func (o *QueryTaskReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type QueryTaskResultsBadRequest 

type QueryTaskResultsBadRequest struct {
	Payload *models.Error
}
QueryTaskResultsBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewQueryTaskResultsBadRequest 

func NewQueryTaskResultsBadRequest() *QueryTaskResultsBadRequest

NewQueryTaskResultsBadRequest creates a QueryTaskResultsBadRequest with default headers values

func (*QueryTaskResultsBadRequest) Error 

func (o *QueryTaskResultsBadRequest) Error() string

func (*QueryTaskResultsBadRequest) GetPayload 

func (o *QueryTaskResultsBadRequest) GetPayload() *models.Error

type QueryTaskResultsNoContent 

type QueryTaskResultsNoContent struct {
	Payload string
}
QueryTaskResultsNoContent describes a response with status code 204, with default header values.

The query is not finished

func NewQueryTaskResultsNoContent 

func NewQueryTaskResultsNoContent() *QueryTaskResultsNoContent

NewQueryTaskResultsNoContent creates a QueryTaskResultsNoContent with default headers values

func (*QueryTaskResultsNoContent) Error 

func (o *QueryTaskResultsNoContent) Error() string

func (*QueryTaskResultsNoContent) GetPayload 

func (o *QueryTaskResultsNoContent) GetPayload() string

type QueryTaskResultsNotFound 

type QueryTaskResultsNotFound struct {
	Payload *models.Error
}
QueryTaskResultsNotFound describes a response with status code 404, with default header values.

The Query Task Id was not found or the results have expired.

func NewQueryTaskResultsNotFound 

func NewQueryTaskResultsNotFound() *QueryTaskResultsNotFound

NewQueryTaskResultsNotFound creates a QueryTaskResultsNotFound with default headers values

func (*QueryTaskResultsNotFound) Error 

func (o *QueryTaskResultsNotFound) Error() string

func (*QueryTaskResultsNotFound) GetPayload 

func (o *QueryTaskResultsNotFound) GetPayload() *models.Error

type QueryTaskResultsOK 

type QueryTaskResultsOK struct {
	Payload string
}
QueryTaskResultsOK describes a response with status code 200, with default header values.

The query results.

func NewQueryTaskResultsOK 

func NewQueryTaskResultsOK() *QueryTaskResultsOK

NewQueryTaskResultsOK creates a QueryTaskResultsOK with default headers values

func (*QueryTaskResultsOK) Error 

func (o *QueryTaskResultsOK) Error() string

func (*QueryTaskResultsOK) GetPayload 

func (o *QueryTaskResultsOK) GetPayload() string

type QueryTaskResultsParams 

type QueryTaskResultsParams struct {

	/* QueryTaskID.

	   ID of the Query Task
	*/
	QueryTaskID string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

QueryTaskResultsParams contains all the parameters to send to the API endpoint 

for the query task results operation.

Typically these are written to a http.Request.

func NewQueryTaskResultsParams 

func NewQueryTaskResultsParams() *QueryTaskResultsParams

NewQueryTaskResultsParams creates a new QueryTaskResultsParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewQueryTaskResultsParamsWithContext 

func NewQueryTaskResultsParamsWithContext(ctx context.Context) *QueryTaskResultsParams

NewQueryTaskResultsParamsWithContext creates a new QueryTaskResultsParams object with the ability to set a context for a request.

func NewQueryTaskResultsParamsWithHTTPClient 

func NewQueryTaskResultsParamsWithHTTPClient(client *http.Client) *QueryTaskResultsParams

NewQueryTaskResultsParamsWithHTTPClient creates a new QueryTaskResultsParams object with the ability to set a custom HTTPClient for a request.

func NewQueryTaskResultsParamsWithTimeout 

func NewQueryTaskResultsParamsWithTimeout(timeout time.Duration) *QueryTaskResultsParams

NewQueryTaskResultsParamsWithTimeout creates a new QueryTaskResultsParams object with the ability to set a timeout on a request.

func (*QueryTaskResultsParams) SetContext 

func (o *QueryTaskResultsParams) SetContext(ctx context.Context)

SetContext adds the context to the query task results params

func (*QueryTaskResultsParams) SetDefaults 

func (o *QueryTaskResultsParams) SetDefaults()

SetDefaults hydrates default values in the query task results params (not the query body).

All values with no default are reset to their zero value.

func (*QueryTaskResultsParams) SetHTTPClient 

func (o *QueryTaskResultsParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the query task results params

func (*QueryTaskResultsParams) SetQueryTaskID 

func (o *QueryTaskResultsParams) SetQueryTaskID(queryTaskID string)

SetQueryTaskID adds the queryTaskId to the query task results params

func (*QueryTaskResultsParams) SetTimeout 

func (o *QueryTaskResultsParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the query task results params

func (*QueryTaskResultsParams) WithContext 

func (o *QueryTaskResultsParams) WithContext(ctx context.Context) *QueryTaskResultsParams

WithContext adds the context to the query task results params

func (*QueryTaskResultsParams) WithDefaults 

func (o *QueryTaskResultsParams) WithDefaults() *QueryTaskResultsParams

WithDefaults hydrates default values in the query task results params (not the query body).

All values with no default are reset to their zero value.

func (*QueryTaskResultsParams) WithHTTPClient 

func (o *QueryTaskResultsParams) WithHTTPClient(client *http.Client) *QueryTaskResultsParams

WithHTTPClient adds the HTTPClient to the query task results params

func (*QueryTaskResultsParams) WithQueryTaskID 

func (o *QueryTaskResultsParams) WithQueryTaskID(queryTaskID string) *QueryTaskResultsParams

WithQueryTaskID adds the queryTaskID to the query task results params

func (*QueryTaskResultsParams) WithTimeout 

func (o *QueryTaskResultsParams) WithTimeout(timeout time.Duration) *QueryTaskResultsParams

WithTimeout adds the timeout to the query task results params

func (*QueryTaskResultsParams) WriteToRequest 

func (o *QueryTaskResultsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type QueryTaskResultsReader 

type QueryTaskResultsReader struct {
	// contains filtered or unexported fields
}

QueryTaskResultsReader is a Reader for the QueryTaskResults structure.

func (*QueryTaskResultsReader) ReadResponse 

func (o *QueryTaskResultsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type RunInlineQueryBadRequest 

type RunInlineQueryBadRequest struct {
	Payload *models.Error
}
RunInlineQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewRunInlineQueryBadRequest 

func NewRunInlineQueryBadRequest() *RunInlineQueryBadRequest

NewRunInlineQueryBadRequest creates a RunInlineQueryBadRequest with default headers values

func (*RunInlineQueryBadRequest) Error 

func (o *RunInlineQueryBadRequest) Error() string

func (*RunInlineQueryBadRequest) GetPayload 

func (o *RunInlineQueryBadRequest) GetPayload() *models.Error

type RunInlineQueryNotFound 

type RunInlineQueryNotFound struct {
	Payload *models.Error
}
RunInlineQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewRunInlineQueryNotFound 

func NewRunInlineQueryNotFound() *RunInlineQueryNotFound

NewRunInlineQueryNotFound creates a RunInlineQueryNotFound with default headers values

func (*RunInlineQueryNotFound) Error 

func (o *RunInlineQueryNotFound) Error() string

func (*RunInlineQueryNotFound) GetPayload 

func (o *RunInlineQueryNotFound) GetPayload() *models.Error

type RunInlineQueryOK 

type RunInlineQueryOK struct {
	Payload string
}
RunInlineQueryOK describes a response with status code 200, with default header values.

Query Result

func NewRunInlineQueryOK 

func NewRunInlineQueryOK() *RunInlineQueryOK

NewRunInlineQueryOK creates a RunInlineQueryOK with default headers values

func (*RunInlineQueryOK) Error 

func (o *RunInlineQueryOK) Error() string

func (*RunInlineQueryOK) GetPayload 

func (o *RunInlineQueryOK) GetPayload() string

type RunInlineQueryParams 

type RunInlineQueryParams struct {

	/* ApplyFormatting.

	   Apply model-specified formatting to each result.
	*/
	ApplyFormatting *bool

	/* ApplyVis.

	   Apply visualization options to results.
	*/
	ApplyVis *bool

	/* Body.

	   inline query
	*/
	Body *models.Query

	/* Cache.

	   Get results from cache if available.
	*/
	Cache *bool

	/* CacheOnly.

	   Retrieve any results from cache even if the results have expired.
	*/
	CacheOnly *bool

	/* ForceProduction.

	   Force use of production models even if the user is in development mode.
	*/
	ForceProduction *bool

	/* GenerateDrillLinks.

	   Generate drill links (only applicable to 'json_detail' format.
	*/
	GenerateDrillLinks *bool

	/* ImageHeight.

	   Render height for image formats.

	   Format: int64
	*/
	ImageHeight *int64

	/* ImageWidth.

	   Render width for image formats.

	   Format: int64
	*/
	ImageWidth *int64

	/* Limit.

	   Row limit (may override the limit in the saved query).

	   Format: int64
	*/
	Limit *int64

	/* PathPrefix.

	   Prefix to use for drill links (url encoded).
	*/
	PathPrefix *string

	/* RebuildPdts.

	   Rebuild PDTS used in query.
	*/
	RebuildPdts *bool

	/* ResultFormat.

	   Format of result
	*/
	ResultFormat string

	/* ServerTableCalcs.

	   Perform table calculations on query results
	*/
	ServerTableCalcs *bool

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

RunInlineQueryParams contains all the parameters to send to the API endpoint 

for the run inline query operation.

Typically these are written to a http.Request.

func NewRunInlineQueryParams 

func NewRunInlineQueryParams() *RunInlineQueryParams

NewRunInlineQueryParams creates a new RunInlineQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewRunInlineQueryParamsWithContext 

func NewRunInlineQueryParamsWithContext(ctx context.Context) *RunInlineQueryParams

NewRunInlineQueryParamsWithContext creates a new RunInlineQueryParams object with the ability to set a context for a request.

func NewRunInlineQueryParamsWithHTTPClient 

func NewRunInlineQueryParamsWithHTTPClient(client *http.Client) *RunInlineQueryParams

NewRunInlineQueryParamsWithHTTPClient creates a new RunInlineQueryParams object with the ability to set a custom HTTPClient for a request.

func NewRunInlineQueryParamsWithTimeout 

func NewRunInlineQueryParamsWithTimeout(timeout time.Duration) *RunInlineQueryParams

NewRunInlineQueryParamsWithTimeout creates a new RunInlineQueryParams object with the ability to set a timeout on a request.

func (*RunInlineQueryParams) SetApplyFormatting 

func (o *RunInlineQueryParams) SetApplyFormatting(applyFormatting *bool)

SetApplyFormatting adds the applyFormatting to the run inline query params

func (*RunInlineQueryParams) SetApplyVis 

func (o *RunInlineQueryParams) SetApplyVis(applyVis *bool)

SetApplyVis adds the applyVis to the run inline query params

func (*RunInlineQueryParams) SetBody 

func (o *RunInlineQueryParams) SetBody(body *models.Query)

SetBody adds the body to the run inline query params

func (*RunInlineQueryParams) SetCache 

func (o *RunInlineQueryParams) SetCache(cache *bool)

SetCache adds the cache to the run inline query params

func (*RunInlineQueryParams) SetCacheOnly 

func (o *RunInlineQueryParams) SetCacheOnly(cacheOnly *bool)

SetCacheOnly adds the cacheOnly to the run inline query params

func (*RunInlineQueryParams) SetContext 

func (o *RunInlineQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the run inline query params

func (*RunInlineQueryParams) SetDefaults 

func (o *RunInlineQueryParams) SetDefaults()

SetDefaults hydrates default values in the run inline query params (not the query body).

All values with no default are reset to their zero value.

func (*RunInlineQueryParams) SetForceProduction 

func (o *RunInlineQueryParams) SetForceProduction(forceProduction *bool)

SetForceProduction adds the forceProduction to the run inline query params 

func (o *RunInlineQueryParams) SetGenerateDrillLinks(generateDrillLinks *bool)

SetGenerateDrillLinks adds the generateDrillLinks to the run inline query params

func (*RunInlineQueryParams) SetHTTPClient 

func (o *RunInlineQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the run inline query params

func (*RunInlineQueryParams) SetImageHeight 

func (o *RunInlineQueryParams) SetImageHeight(imageHeight *int64)

SetImageHeight adds the imageHeight to the run inline query params

func (*RunInlineQueryParams) SetImageWidth 

func (o *RunInlineQueryParams) SetImageWidth(imageWidth *int64)

SetImageWidth adds the imageWidth to the run inline query params

func (*RunInlineQueryParams) SetLimit 

func (o *RunInlineQueryParams) SetLimit(limit *int64)

SetLimit adds the limit to the run inline query params

func (*RunInlineQueryParams) SetPathPrefix 

func (o *RunInlineQueryParams) SetPathPrefix(pathPrefix *string)

SetPathPrefix adds the pathPrefix to the run inline query params

func (*RunInlineQueryParams) SetRebuildPdts 

func (o *RunInlineQueryParams) SetRebuildPdts(rebuildPdts *bool)

SetRebuildPdts adds the rebuildPdts to the run inline query params

func (*RunInlineQueryParams) SetResultFormat 

func (o *RunInlineQueryParams) SetResultFormat(resultFormat string)

SetResultFormat adds the resultFormat to the run inline query params

func (*RunInlineQueryParams) SetServerTableCalcs 

func (o *RunInlineQueryParams) SetServerTableCalcs(serverTableCalcs *bool)

SetServerTableCalcs adds the serverTableCalcs to the run inline query params

func (*RunInlineQueryParams) SetTimeout 

func (o *RunInlineQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the run inline query params

func (*RunInlineQueryParams) WithApplyFormatting 

func (o *RunInlineQueryParams) WithApplyFormatting(applyFormatting *bool) *RunInlineQueryParams

WithApplyFormatting adds the applyFormatting to the run inline query params

func (*RunInlineQueryParams) WithApplyVis 

func (o *RunInlineQueryParams) WithApplyVis(applyVis *bool) *RunInlineQueryParams

WithApplyVis adds the applyVis to the run inline query params

func (*RunInlineQueryParams) WithBody 

func (o *RunInlineQueryParams) WithBody(body *models.Query) *RunInlineQueryParams

WithBody adds the body to the run inline query params

func (*RunInlineQueryParams) WithCache 

func (o *RunInlineQueryParams) WithCache(cache *bool) *RunInlineQueryParams

WithCache adds the cache to the run inline query params

func (*RunInlineQueryParams) WithCacheOnly 

func (o *RunInlineQueryParams) WithCacheOnly(cacheOnly *bool) *RunInlineQueryParams

WithCacheOnly adds the cacheOnly to the run inline query params

func (*RunInlineQueryParams) WithContext 

func (o *RunInlineQueryParams) WithContext(ctx context.Context) *RunInlineQueryParams

WithContext adds the context to the run inline query params

func (*RunInlineQueryParams) WithDefaults 

func (o *RunInlineQueryParams) WithDefaults() *RunInlineQueryParams

WithDefaults hydrates default values in the run inline query params (not the query body).

All values with no default are reset to their zero value.

func (*RunInlineQueryParams) WithForceProduction 

func (o *RunInlineQueryParams) WithForceProduction(forceProduction *bool) *RunInlineQueryParams

WithForceProduction adds the forceProduction to the run inline query params 

func (o *RunInlineQueryParams) WithGenerateDrillLinks(generateDrillLinks *bool) *RunInlineQueryParams

WithGenerateDrillLinks adds the generateDrillLinks to the run inline query params

func (*RunInlineQueryParams) WithHTTPClient 

func (o *RunInlineQueryParams) WithHTTPClient(client *http.Client) *RunInlineQueryParams

WithHTTPClient adds the HTTPClient to the run inline query params

func (*RunInlineQueryParams) WithImageHeight 

func (o *RunInlineQueryParams) WithImageHeight(imageHeight *int64) *RunInlineQueryParams

WithImageHeight adds the imageHeight to the run inline query params

func (*RunInlineQueryParams) WithImageWidth 

func (o *RunInlineQueryParams) WithImageWidth(imageWidth *int64) *RunInlineQueryParams

WithImageWidth adds the imageWidth to the run inline query params

func (*RunInlineQueryParams) WithLimit 

func (o *RunInlineQueryParams) WithLimit(limit *int64) *RunInlineQueryParams

WithLimit adds the limit to the run inline query params

func (*RunInlineQueryParams) WithPathPrefix 

func (o *RunInlineQueryParams) WithPathPrefix(pathPrefix *string) *RunInlineQueryParams

WithPathPrefix adds the pathPrefix to the run inline query params

func (*RunInlineQueryParams) WithRebuildPdts 

func (o *RunInlineQueryParams) WithRebuildPdts(rebuildPdts *bool) *RunInlineQueryParams

WithRebuildPdts adds the rebuildPdts to the run inline query params

func (*RunInlineQueryParams) WithResultFormat 

func (o *RunInlineQueryParams) WithResultFormat(resultFormat string) *RunInlineQueryParams

WithResultFormat adds the resultFormat to the run inline query params

func (*RunInlineQueryParams) WithServerTableCalcs 

func (o *RunInlineQueryParams) WithServerTableCalcs(serverTableCalcs *bool) *RunInlineQueryParams

WithServerTableCalcs adds the serverTableCalcs to the run inline query params

func (*RunInlineQueryParams) WithTimeout 

func (o *RunInlineQueryParams) WithTimeout(timeout time.Duration) *RunInlineQueryParams

WithTimeout adds the timeout to the run inline query params

func (*RunInlineQueryParams) WriteToRequest 

func (o *RunInlineQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type RunInlineQueryReader 

type RunInlineQueryReader struct {
	// contains filtered or unexported fields
}

RunInlineQueryReader is a Reader for the RunInlineQuery structure.

func (*RunInlineQueryReader) ReadResponse 

func (o *RunInlineQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type RunInlineQueryTooManyRequests 

type RunInlineQueryTooManyRequests struct {
	Payload *models.Error
}
RunInlineQueryTooManyRequests describes a response with status code 429, with default header values.

Too Many Requests

func NewRunInlineQueryTooManyRequests 

func NewRunInlineQueryTooManyRequests() *RunInlineQueryTooManyRequests

NewRunInlineQueryTooManyRequests creates a RunInlineQueryTooManyRequests with default headers values

func (*RunInlineQueryTooManyRequests) Error 

func (o *RunInlineQueryTooManyRequests) Error() string

func (*RunInlineQueryTooManyRequests) GetPayload 

func (o *RunInlineQueryTooManyRequests) GetPayload() *models.Error

type RunInlineQueryUnprocessableEntity 

type RunInlineQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}
RunInlineQueryUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewRunInlineQueryUnprocessableEntity 

func NewRunInlineQueryUnprocessableEntity() *RunInlineQueryUnprocessableEntity

NewRunInlineQueryUnprocessableEntity creates a RunInlineQueryUnprocessableEntity with default headers values

func (*RunInlineQueryUnprocessableEntity) Error 

func (o *RunInlineQueryUnprocessableEntity) Error() string

func (*RunInlineQueryUnprocessableEntity) GetPayload 

func (o *RunInlineQueryUnprocessableEntity) GetPayload() *models.ValidationError

type RunQueryBadRequest 

type RunQueryBadRequest struct {
	Payload *models.Error
}
RunQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewRunQueryBadRequest 

func NewRunQueryBadRequest() *RunQueryBadRequest

NewRunQueryBadRequest creates a RunQueryBadRequest with default headers values

func (*RunQueryBadRequest) Error 

func (o *RunQueryBadRequest) Error() string

func (*RunQueryBadRequest) GetPayload 

func (o *RunQueryBadRequest) GetPayload() *models.Error

type RunQueryNotFound 

type RunQueryNotFound struct {
	Payload *models.Error
}
RunQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewRunQueryNotFound 

func NewRunQueryNotFound() *RunQueryNotFound

NewRunQueryNotFound creates a RunQueryNotFound with default headers values

func (*RunQueryNotFound) Error 

func (o *RunQueryNotFound) Error() string

func (*RunQueryNotFound) GetPayload 

func (o *RunQueryNotFound) GetPayload() *models.Error

type RunQueryOK 

type RunQueryOK struct {
	Payload string
}
RunQueryOK describes a response with status code 200, with default header values.

Query

func NewRunQueryOK 

func NewRunQueryOK() *RunQueryOK

NewRunQueryOK creates a RunQueryOK with default headers values

func (*RunQueryOK) Error 

func (o *RunQueryOK) Error() string

func (*RunQueryOK) GetPayload 

func (o *RunQueryOK) GetPayload() string

type RunQueryParams 

type RunQueryParams struct {

	/* ApplyFormatting.

	   Apply model-specified formatting to each result.
	*/
	ApplyFormatting *bool

	/* ApplyVis.

	   Apply visualization options to results.
	*/
	ApplyVis *bool

	/* Cache.

	   Get results from cache if available.
	*/
	Cache *bool

	/* CacheOnly.

	   Retrieve any results from cache even if the results have expired.
	*/
	CacheOnly *bool

	/* ForceProduction.

	   Force use of production models even if the user is in development mode.
	*/
	ForceProduction *bool

	/* GenerateDrillLinks.

	   Generate drill links (only applicable to 'json_detail' format.
	*/
	GenerateDrillLinks *bool

	/* ImageHeight.

	   Render height for image formats.

	   Format: int64
	*/
	ImageHeight *int64

	/* ImageWidth.

	   Render width for image formats.

	   Format: int64
	*/
	ImageWidth *int64

	/* Limit.

	   Row limit (may override the limit in the saved query).

	   Format: int64
	*/
	Limit *int64

	/* PathPrefix.

	   Prefix to use for drill links (url encoded).
	*/
	PathPrefix *string

	/* QueryID.

	   Id of query

	   Format: int64
	*/
	QueryID int64

	/* RebuildPdts.

	   Rebuild PDTS used in query.
	*/
	RebuildPdts *bool

	/* ResultFormat.

	   Format of result
	*/
	ResultFormat string

	/* ServerTableCalcs.

	   Perform table calculations on query results
	*/
	ServerTableCalcs *bool

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

RunQueryParams contains all the parameters to send to the API endpoint 

for the run query operation.

Typically these are written to a http.Request.

func NewRunQueryParams 

func NewRunQueryParams() *RunQueryParams

NewRunQueryParams creates a new RunQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewRunQueryParamsWithContext 

func NewRunQueryParamsWithContext(ctx context.Context) *RunQueryParams

NewRunQueryParamsWithContext creates a new RunQueryParams object with the ability to set a context for a request.

func NewRunQueryParamsWithHTTPClient 

func NewRunQueryParamsWithHTTPClient(client *http.Client) *RunQueryParams

NewRunQueryParamsWithHTTPClient creates a new RunQueryParams object with the ability to set a custom HTTPClient for a request.

func NewRunQueryParamsWithTimeout 

func NewRunQueryParamsWithTimeout(timeout time.Duration) *RunQueryParams

NewRunQueryParamsWithTimeout creates a new RunQueryParams object with the ability to set a timeout on a request.

func (*RunQueryParams) SetApplyFormatting 

func (o *RunQueryParams) SetApplyFormatting(applyFormatting *bool)

SetApplyFormatting adds the applyFormatting to the run query params

func (*RunQueryParams) SetApplyVis 

func (o *RunQueryParams) SetApplyVis(applyVis *bool)

SetApplyVis adds the applyVis to the run query params

func (*RunQueryParams) SetCache 

func (o *RunQueryParams) SetCache(cache *bool)

SetCache adds the cache to the run query params

func (*RunQueryParams) SetCacheOnly 

func (o *RunQueryParams) SetCacheOnly(cacheOnly *bool)

SetCacheOnly adds the cacheOnly to the run query params

func (*RunQueryParams) SetContext 

func (o *RunQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the run query params

func (*RunQueryParams) SetDefaults 

func (o *RunQueryParams) SetDefaults()

SetDefaults hydrates default values in the run query params (not the query body).

All values with no default are reset to their zero value.

func (*RunQueryParams) SetForceProduction 

func (o *RunQueryParams) SetForceProduction(forceProduction *bool)

SetForceProduction adds the forceProduction to the run query params 

func (o *RunQueryParams) SetGenerateDrillLinks(generateDrillLinks *bool)

SetGenerateDrillLinks adds the generateDrillLinks to the run query params

func (*RunQueryParams) SetHTTPClient 

func (o *RunQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the run query params

func (*RunQueryParams) SetImageHeight 

func (o *RunQueryParams) SetImageHeight(imageHeight *int64)

SetImageHeight adds the imageHeight to the run query params

func (*RunQueryParams) SetImageWidth 

func (o *RunQueryParams) SetImageWidth(imageWidth *int64)

SetImageWidth adds the imageWidth to the run query params

func (*RunQueryParams) SetLimit 

func (o *RunQueryParams) SetLimit(limit *int64)

SetLimit adds the limit to the run query params

func (*RunQueryParams) SetPathPrefix 

func (o *RunQueryParams) SetPathPrefix(pathPrefix *string)

SetPathPrefix adds the pathPrefix to the run query params

func (*RunQueryParams) SetQueryID 

func (o *RunQueryParams) SetQueryID(queryID int64)

SetQueryID adds the queryId to the run query params

func (*RunQueryParams) SetRebuildPdts 

func (o *RunQueryParams) SetRebuildPdts(rebuildPdts *bool)

SetRebuildPdts adds the rebuildPdts to the run query params

func (*RunQueryParams) SetResultFormat 

func (o *RunQueryParams) SetResultFormat(resultFormat string)

SetResultFormat adds the resultFormat to the run query params

func (*RunQueryParams) SetServerTableCalcs 

func (o *RunQueryParams) SetServerTableCalcs(serverTableCalcs *bool)

SetServerTableCalcs adds the serverTableCalcs to the run query params

func (*RunQueryParams) SetTimeout 

func (o *RunQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the run query params

func (*RunQueryParams) WithApplyFormatting 

func (o *RunQueryParams) WithApplyFormatting(applyFormatting *bool) *RunQueryParams

WithApplyFormatting adds the applyFormatting to the run query params

func (*RunQueryParams) WithApplyVis 

func (o *RunQueryParams) WithApplyVis(applyVis *bool) *RunQueryParams

WithApplyVis adds the applyVis to the run query params

func (*RunQueryParams) WithCache 

func (o *RunQueryParams) WithCache(cache *bool) *RunQueryParams

WithCache adds the cache to the run query params

func (*RunQueryParams) WithCacheOnly 

func (o *RunQueryParams) WithCacheOnly(cacheOnly *bool) *RunQueryParams

WithCacheOnly adds the cacheOnly to the run query params

func (*RunQueryParams) WithContext 

func (o *RunQueryParams) WithContext(ctx context.Context) *RunQueryParams

WithContext adds the context to the run query params

func (*RunQueryParams) WithDefaults 

func (o *RunQueryParams) WithDefaults() *RunQueryParams

WithDefaults hydrates default values in the run query params (not the query body).

All values with no default are reset to their zero value.

func (*RunQueryParams) WithForceProduction 

func (o *RunQueryParams) WithForceProduction(forceProduction *bool) *RunQueryParams

WithForceProduction adds the forceProduction to the run query params 

func (o *RunQueryParams) WithGenerateDrillLinks(generateDrillLinks *bool) *RunQueryParams

WithGenerateDrillLinks adds the generateDrillLinks to the run query params

func (*RunQueryParams) WithHTTPClient 

func (o *RunQueryParams) WithHTTPClient(client *http.Client) *RunQueryParams

WithHTTPClient adds the HTTPClient to the run query params

func (*RunQueryParams) WithImageHeight 

func (o *RunQueryParams) WithImageHeight(imageHeight *int64) *RunQueryParams

WithImageHeight adds the imageHeight to the run query params

func (*RunQueryParams) WithImageWidth 

func (o *RunQueryParams) WithImageWidth(imageWidth *int64) *RunQueryParams

WithImageWidth adds the imageWidth to the run query params

func (*RunQueryParams) WithLimit 

func (o *RunQueryParams) WithLimit(limit *int64) *RunQueryParams

WithLimit adds the limit to the run query params

func (*RunQueryParams) WithPathPrefix 

func (o *RunQueryParams) WithPathPrefix(pathPrefix *string) *RunQueryParams

WithPathPrefix adds the pathPrefix to the run query params

func (*RunQueryParams) WithQueryID 

func (o *RunQueryParams) WithQueryID(queryID int64) *RunQueryParams

WithQueryID adds the queryID to the run query params

func (*RunQueryParams) WithRebuildPdts 

func (o *RunQueryParams) WithRebuildPdts(rebuildPdts *bool) *RunQueryParams

WithRebuildPdts adds the rebuildPdts to the run query params

func (*RunQueryParams) WithResultFormat 

func (o *RunQueryParams) WithResultFormat(resultFormat string) *RunQueryParams

WithResultFormat adds the resultFormat to the run query params

func (*RunQueryParams) WithServerTableCalcs 

func (o *RunQueryParams) WithServerTableCalcs(serverTableCalcs *bool) *RunQueryParams

WithServerTableCalcs adds the serverTableCalcs to the run query params

func (*RunQueryParams) WithTimeout 

func (o *RunQueryParams) WithTimeout(timeout time.Duration) *RunQueryParams

WithTimeout adds the timeout to the run query params

func (*RunQueryParams) WriteToRequest 

func (o *RunQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type RunQueryReader 

type RunQueryReader struct {
	// contains filtered or unexported fields
}

RunQueryReader is a Reader for the RunQuery structure.

func (*RunQueryReader) ReadResponse 

func (o *RunQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type RunQueryTooManyRequests 

type RunQueryTooManyRequests struct {
	Payload *models.Error
}
RunQueryTooManyRequests describes a response with status code 429, with default header values.

Too Many Requests

func NewRunQueryTooManyRequests 

func NewRunQueryTooManyRequests() *RunQueryTooManyRequests

NewRunQueryTooManyRequests creates a RunQueryTooManyRequests with default headers values

func (*RunQueryTooManyRequests) Error 

func (o *RunQueryTooManyRequests) Error() string

func (*RunQueryTooManyRequests) GetPayload 

func (o *RunQueryTooManyRequests) GetPayload() *models.Error

type RunQueryUnprocessableEntity 

type RunQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}
RunQueryUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewRunQueryUnprocessableEntity 

func NewRunQueryUnprocessableEntity() *RunQueryUnprocessableEntity

NewRunQueryUnprocessableEntity creates a RunQueryUnprocessableEntity with default headers values

func (*RunQueryUnprocessableEntity) Error 

func (o *RunQueryUnprocessableEntity) Error() string

func (*RunQueryUnprocessableEntity) GetPayload 

func (o *RunQueryUnprocessableEntity) GetPayload() *models.ValidationError

type RunSQLQueryBadRequest 

type RunSQLQueryBadRequest struct {
	Payload *models.Error
}
RunSQLQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewRunSQLQueryBadRequest 

func NewRunSQLQueryBadRequest() *RunSQLQueryBadRequest

NewRunSQLQueryBadRequest creates a RunSQLQueryBadRequest with default headers values

func (*RunSQLQueryBadRequest) Error 

func (o *RunSQLQueryBadRequest) Error() string

func (*RunSQLQueryBadRequest) GetPayload 

func (o *RunSQLQueryBadRequest) GetPayload() *models.Error

type RunSQLQueryNotFound 

type RunSQLQueryNotFound struct {
	Payload *models.Error
}
RunSQLQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewRunSQLQueryNotFound 

func NewRunSQLQueryNotFound() *RunSQLQueryNotFound

NewRunSQLQueryNotFound creates a RunSQLQueryNotFound with default headers values

func (*RunSQLQueryNotFound) Error 

func (o *RunSQLQueryNotFound) Error() string

func (*RunSQLQueryNotFound) GetPayload 

func (o *RunSQLQueryNotFound) GetPayload() *models.Error

type RunSQLQueryOK 

type RunSQLQueryOK struct {
	Payload string
}
RunSQLQueryOK describes a response with status code 200, with default header values.

SQL Runner Query

func NewRunSQLQueryOK 

func NewRunSQLQueryOK() *RunSQLQueryOK

NewRunSQLQueryOK creates a RunSQLQueryOK with default headers values

func (*RunSQLQueryOK) Error 

func (o *RunSQLQueryOK) Error() string

func (*RunSQLQueryOK) GetPayload 

func (o *RunSQLQueryOK) GetPayload() string

type RunSQLQueryParams 

type RunSQLQueryParams struct {

	/* Download.

	   Defaults to false. If set to true, the HTTP response will have content-disposition and other headers set to make the HTTP response behave as a downloadable attachment instead of as inline content.
	*/
	Download *string

	/* ResultFormat.

	   Format of result, options are: ["inline_json", "json", "json_detail", "json_fe", "csv", "html", "md", "txt", "xlsx", "gsxml", "json_label"]
	*/
	ResultFormat string

	/* Slug.

	   slug of query
	*/
	Slug string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

RunSQLQueryParams contains all the parameters to send to the API endpoint 

for the run sql query operation.

Typically these are written to a http.Request.

func NewRunSQLQueryParams 

func NewRunSQLQueryParams() *RunSQLQueryParams

NewRunSQLQueryParams creates a new RunSQLQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewRunSQLQueryParamsWithContext 

func NewRunSQLQueryParamsWithContext(ctx context.Context) *RunSQLQueryParams

NewRunSQLQueryParamsWithContext creates a new RunSQLQueryParams object with the ability to set a context for a request.

func NewRunSQLQueryParamsWithHTTPClient 

func NewRunSQLQueryParamsWithHTTPClient(client *http.Client) *RunSQLQueryParams

NewRunSQLQueryParamsWithHTTPClient creates a new RunSQLQueryParams object with the ability to set a custom HTTPClient for a request.

func NewRunSQLQueryParamsWithTimeout 

func NewRunSQLQueryParamsWithTimeout(timeout time.Duration) *RunSQLQueryParams

NewRunSQLQueryParamsWithTimeout creates a new RunSQLQueryParams object with the ability to set a timeout on a request.

func (*RunSQLQueryParams) SetContext 

func (o *RunSQLQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the run sql query params

func (*RunSQLQueryParams) SetDefaults 

func (o *RunSQLQueryParams) SetDefaults()

SetDefaults hydrates default values in the run sql query params (not the query body).

All values with no default are reset to their zero value.

func (*RunSQLQueryParams) SetDownload 

func (o *RunSQLQueryParams) SetDownload(download *string)

SetDownload adds the download to the run sql query params

func (*RunSQLQueryParams) SetHTTPClient 

func (o *RunSQLQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the run sql query params

func (*RunSQLQueryParams) SetResultFormat 

func (o *RunSQLQueryParams) SetResultFormat(resultFormat string)

SetResultFormat adds the resultFormat to the run sql query params

func (*RunSQLQueryParams) SetSlug 

func (o *RunSQLQueryParams) SetSlug(slug string)

SetSlug adds the slug to the run sql query params

func (*RunSQLQueryParams) SetTimeout 

func (o *RunSQLQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the run sql query params

func (*RunSQLQueryParams) WithContext 

func (o *RunSQLQueryParams) WithContext(ctx context.Context) *RunSQLQueryParams

WithContext adds the context to the run sql query params

func (*RunSQLQueryParams) WithDefaults 

func (o *RunSQLQueryParams) WithDefaults() *RunSQLQueryParams

WithDefaults hydrates default values in the run sql query params (not the query body).

All values with no default are reset to their zero value.

func (*RunSQLQueryParams) WithDownload 

func (o *RunSQLQueryParams) WithDownload(download *string) *RunSQLQueryParams

WithDownload adds the download to the run sql query params

func (*RunSQLQueryParams) WithHTTPClient 

func (o *RunSQLQueryParams) WithHTTPClient(client *http.Client) *RunSQLQueryParams

WithHTTPClient adds the HTTPClient to the run sql query params

func (*RunSQLQueryParams) WithResultFormat 

func (o *RunSQLQueryParams) WithResultFormat(resultFormat string) *RunSQLQueryParams

WithResultFormat adds the resultFormat to the run sql query params

func (*RunSQLQueryParams) WithSlug 

func (o *RunSQLQueryParams) WithSlug(slug string) *RunSQLQueryParams

WithSlug adds the slug to the run sql query params

func (*RunSQLQueryParams) WithTimeout 

func (o *RunSQLQueryParams) WithTimeout(timeout time.Duration) *RunSQLQueryParams

WithTimeout adds the timeout to the run sql query params

func (*RunSQLQueryParams) WriteToRequest 

func (o *RunSQLQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type RunSQLQueryReader 

type RunSQLQueryReader struct {
	// contains filtered or unexported fields
}

RunSQLQueryReader is a Reader for the RunSQLQuery structure.

func (*RunSQLQueryReader) ReadResponse 

func (o *RunSQLQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type RunSQLQueryTooManyRequests 

type RunSQLQueryTooManyRequests struct {
	Payload *models.Error
}
RunSQLQueryTooManyRequests describes a response with status code 429, with default header values.

Too Many Requests

func NewRunSQLQueryTooManyRequests 

func NewRunSQLQueryTooManyRequests() *RunSQLQueryTooManyRequests

NewRunSQLQueryTooManyRequests creates a RunSQLQueryTooManyRequests with default headers values

func (*RunSQLQueryTooManyRequests) Error 

func (o *RunSQLQueryTooManyRequests) Error() string

func (*RunSQLQueryTooManyRequests) GetPayload 

func (o *RunSQLQueryTooManyRequests) GetPayload() *models.Error

type RunSQLQueryUnprocessableEntity 

type RunSQLQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}
RunSQLQueryUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewRunSQLQueryUnprocessableEntity 

func NewRunSQLQueryUnprocessableEntity() *RunSQLQueryUnprocessableEntity

NewRunSQLQueryUnprocessableEntity creates a RunSQLQueryUnprocessableEntity with default headers values

func (*RunSQLQueryUnprocessableEntity) Error 

func (o *RunSQLQueryUnprocessableEntity) Error() string

func (*RunSQLQueryUnprocessableEntity) GetPayload 

func (o *RunSQLQueryUnprocessableEntity) GetPayload() *models.ValidationError

type RunURLEncodedQueryBadRequest 

type RunURLEncodedQueryBadRequest struct {
	Payload *models.Error
}
RunURLEncodedQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewRunURLEncodedQueryBadRequest 

func NewRunURLEncodedQueryBadRequest() *RunURLEncodedQueryBadRequest

NewRunURLEncodedQueryBadRequest creates a RunURLEncodedQueryBadRequest with default headers values

func (*RunURLEncodedQueryBadRequest) Error 

func (o *RunURLEncodedQueryBadRequest) Error() string

func (*RunURLEncodedQueryBadRequest) GetPayload 

func (o *RunURLEncodedQueryBadRequest) GetPayload() *models.Error

type RunURLEncodedQueryNotFound 

type RunURLEncodedQueryNotFound struct {
	Payload *models.Error
}
RunURLEncodedQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewRunURLEncodedQueryNotFound 

func NewRunURLEncodedQueryNotFound() *RunURLEncodedQueryNotFound

NewRunURLEncodedQueryNotFound creates a RunURLEncodedQueryNotFound with default headers values

func (*RunURLEncodedQueryNotFound) Error 

func (o *RunURLEncodedQueryNotFound) Error() string

func (*RunURLEncodedQueryNotFound) GetPayload 

func (o *RunURLEncodedQueryNotFound) GetPayload() *models.Error

type RunURLEncodedQueryOK 

type RunURLEncodedQueryOK struct {
	Payload string
}
RunURLEncodedQueryOK describes a response with status code 200, with default header values.

Query

func NewRunURLEncodedQueryOK 

func NewRunURLEncodedQueryOK() *RunURLEncodedQueryOK

NewRunURLEncodedQueryOK creates a RunURLEncodedQueryOK with default headers values

func (*RunURLEncodedQueryOK) Error 

func (o *RunURLEncodedQueryOK) Error() string

func (*RunURLEncodedQueryOK) GetPayload 

func (o *RunURLEncodedQueryOK) GetPayload() string

type RunURLEncodedQueryParams 

type RunURLEncodedQueryParams struct {

	/* ModelName.

	   Model name
	*/
	ModelName string

	/* ResultFormat.

	   Format of result
	*/
	ResultFormat string

	/* ViewName.

	   View name
	*/
	ViewName string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

RunURLEncodedQueryParams contains all the parameters to send to the API endpoint 

for the run url encoded query operation.

Typically these are written to a http.Request.

func NewRunURLEncodedQueryParams 

func NewRunURLEncodedQueryParams() *RunURLEncodedQueryParams

NewRunURLEncodedQueryParams creates a new RunURLEncodedQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewRunURLEncodedQueryParamsWithContext 

func NewRunURLEncodedQueryParamsWithContext(ctx context.Context) *RunURLEncodedQueryParams

NewRunURLEncodedQueryParamsWithContext creates a new RunURLEncodedQueryParams object with the ability to set a context for a request.

func NewRunURLEncodedQueryParamsWithHTTPClient 

func NewRunURLEncodedQueryParamsWithHTTPClient(client *http.Client) *RunURLEncodedQueryParams

NewRunURLEncodedQueryParamsWithHTTPClient creates a new RunURLEncodedQueryParams object with the ability to set a custom HTTPClient for a request.

func NewRunURLEncodedQueryParamsWithTimeout 

func NewRunURLEncodedQueryParamsWithTimeout(timeout time.Duration) *RunURLEncodedQueryParams

NewRunURLEncodedQueryParamsWithTimeout creates a new RunURLEncodedQueryParams object with the ability to set a timeout on a request.

func (*RunURLEncodedQueryParams) SetContext 

func (o *RunURLEncodedQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the run url encoded query params

func (*RunURLEncodedQueryParams) SetDefaults 

func (o *RunURLEncodedQueryParams) SetDefaults()

SetDefaults hydrates default values in the run url encoded query params (not the query body).

All values with no default are reset to their zero value.

func (*RunURLEncodedQueryParams) SetHTTPClient 

func (o *RunURLEncodedQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the run url encoded query params

func (*RunURLEncodedQueryParams) SetModelName 

func (o *RunURLEncodedQueryParams) SetModelName(modelName string)

SetModelName adds the modelName to the run url encoded query params

func (*RunURLEncodedQueryParams) SetResultFormat 

func (o *RunURLEncodedQueryParams) SetResultFormat(resultFormat string)

SetResultFormat adds the resultFormat to the run url encoded query params

func (*RunURLEncodedQueryParams) SetTimeout 

func (o *RunURLEncodedQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the run url encoded query params

func (*RunURLEncodedQueryParams) SetViewName 

func (o *RunURLEncodedQueryParams) SetViewName(viewName string)

SetViewName adds the viewName to the run url encoded query params

func (*RunURLEncodedQueryParams) WithContext 

func (o *RunURLEncodedQueryParams) WithContext(ctx context.Context) *RunURLEncodedQueryParams

WithContext adds the context to the run url encoded query params

func (*RunURLEncodedQueryParams) WithDefaults 

func (o *RunURLEncodedQueryParams) WithDefaults() *RunURLEncodedQueryParams

WithDefaults hydrates default values in the run url encoded query params (not the query body).

All values with no default are reset to their zero value.

func (*RunURLEncodedQueryParams) WithHTTPClient 

func (o *RunURLEncodedQueryParams) WithHTTPClient(client *http.Client) *RunURLEncodedQueryParams

WithHTTPClient adds the HTTPClient to the run url encoded query params

func (*RunURLEncodedQueryParams) WithModelName 

func (o *RunURLEncodedQueryParams) WithModelName(modelName string) *RunURLEncodedQueryParams

WithModelName adds the modelName to the run url encoded query params

func (*RunURLEncodedQueryParams) WithResultFormat 

func (o *RunURLEncodedQueryParams) WithResultFormat(resultFormat string) *RunURLEncodedQueryParams

WithResultFormat adds the resultFormat to the run url encoded query params

func (*RunURLEncodedQueryParams) WithTimeout 

func (o *RunURLEncodedQueryParams) WithTimeout(timeout time.Duration) *RunURLEncodedQueryParams

WithTimeout adds the timeout to the run url encoded query params

func (*RunURLEncodedQueryParams) WithViewName 

func (o *RunURLEncodedQueryParams) WithViewName(viewName string) *RunURLEncodedQueryParams

WithViewName adds the viewName to the run url encoded query params

func (*RunURLEncodedQueryParams) WriteToRequest 

func (o *RunURLEncodedQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type RunURLEncodedQueryReader 

type RunURLEncodedQueryReader struct {
	// contains filtered or unexported fields
}

RunURLEncodedQueryReader is a Reader for the RunURLEncodedQuery structure.

func (*RunURLEncodedQueryReader) ReadResponse 

func (o *RunURLEncodedQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

type RunURLEncodedQueryTooManyRequests 

type RunURLEncodedQueryTooManyRequests struct {
	Payload *models.Error
}
RunURLEncodedQueryTooManyRequests describes a response with status code 429, with default header values.

Too Many Requests

func NewRunURLEncodedQueryTooManyRequests 

func NewRunURLEncodedQueryTooManyRequests() *RunURLEncodedQueryTooManyRequests

NewRunURLEncodedQueryTooManyRequests creates a RunURLEncodedQueryTooManyRequests with default headers values

func (*RunURLEncodedQueryTooManyRequests) Error 

func (o *RunURLEncodedQueryTooManyRequests) Error() string

func (*RunURLEncodedQueryTooManyRequests) GetPayload 

func (o *RunURLEncodedQueryTooManyRequests) GetPayload() *models.Error

type RunURLEncodedQueryUnprocessableEntity 

type RunURLEncodedQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}
RunURLEncodedQueryUnprocessableEntity describes a response with status code 422, with default header values.

Validation Error

func NewRunURLEncodedQueryUnprocessableEntity 

func NewRunURLEncodedQueryUnprocessableEntity() *RunURLEncodedQueryUnprocessableEntity

NewRunURLEncodedQueryUnprocessableEntity creates a RunURLEncodedQueryUnprocessableEntity with default headers values

func (*RunURLEncodedQueryUnprocessableEntity) Error 

func (o *RunURLEncodedQueryUnprocessableEntity) Error() string

func (*RunURLEncodedQueryUnprocessableEntity) GetPayload 

func (o *RunURLEncodedQueryUnprocessableEntity) GetPayload() *models.ValidationError

type SQLQueryBadRequest 

type SQLQueryBadRequest struct {
	Payload *models.Error
}
SQLQueryBadRequest describes a response with status code 400, with default header values.

Bad Request

func NewSQLQueryBadRequest 

func NewSQLQueryBadRequest() *SQLQueryBadRequest

NewSQLQueryBadRequest creates a SQLQueryBadRequest with default headers values

func (*SQLQueryBadRequest) Error 

func (o *SQLQueryBadRequest) Error() string

func (*SQLQueryBadRequest) GetPayload 

func (o *SQLQueryBadRequest) GetPayload() *models.Error

type SQLQueryNotFound 

type SQLQueryNotFound struct {
	Payload *models.Error
}
SQLQueryNotFound describes a response with status code 404, with default header values.

Not Found

func NewSQLQueryNotFound 

func NewSQLQueryNotFound() *SQLQueryNotFound

NewSQLQueryNotFound creates a SQLQueryNotFound with default headers values

func (*SQLQueryNotFound) Error 

func (o *SQLQueryNotFound) Error() string

func (*SQLQueryNotFound) GetPayload 

func (o *SQLQueryNotFound) GetPayload() *models.Error

type SQLQueryOK 

type SQLQueryOK struct {
	Payload *models.SQLQuery
}
SQLQueryOK describes a response with status code 200, with default header values.

SQL Runner Query

func NewSQLQueryOK 

func NewSQLQueryOK() *SQLQueryOK

NewSQLQueryOK creates a SQLQueryOK with default headers values

func (*SQLQueryOK) Error 

func (o *SQLQueryOK) Error() string

func (*SQLQueryOK) GetPayload 

func (o *SQLQueryOK) GetPayload() *models.SQLQuery

type SQLQueryParams 

type SQLQueryParams struct {

	/* Slug.

	   slug of query
	*/
	Slug string

	Context    context.Context
	HTTPClient *http.Client
	// contains filtered or unexported fields
}

SQLQueryParams contains all the parameters to send to the API endpoint 

for the sql query operation.

Typically these are written to a http.Request.

func NewSQLQueryParams 

func NewSQLQueryParams() *SQLQueryParams

NewSQLQueryParams creates a new SQLQueryParams object, with the default timeout for this client.

Default values are not hydrated, since defaults are normally applied by the API server side.

To enforce default values in parameter, use SetDefaults or WithDefaults.

func NewSQLQueryParamsWithContext 

func NewSQLQueryParamsWithContext(ctx context.Context) *SQLQueryParams

NewSQLQueryParamsWithContext creates a new SQLQueryParams object with the ability to set a context for a request.

func NewSQLQueryParamsWithHTTPClient 

func NewSQLQueryParamsWithHTTPClient(client *http.Client) *SQLQueryParams

NewSQLQueryParamsWithHTTPClient creates a new SQLQueryParams object with the ability to set a custom HTTPClient for a request.

func NewSQLQueryParamsWithTimeout 

func NewSQLQueryParamsWithTimeout(timeout time.Duration) *SQLQueryParams

NewSQLQueryParamsWithTimeout creates a new SQLQueryParams object with the ability to set a timeout on a request.

func (*SQLQueryParams) SetContext 

func (o *SQLQueryParams) SetContext(ctx context.Context)

SetContext adds the context to the sql query params

func (*SQLQueryParams) SetDefaults 

func (o *SQLQueryParams) SetDefaults()

SetDefaults hydrates default values in the sql query params (not the query body).

All values with no default are reset to their zero value.

func (*SQLQueryParams) SetHTTPClient 

func (o *SQLQueryParams) SetHTTPClient(client *http.Client)

SetHTTPClient adds the HTTPClient to the sql query params

func (*SQLQueryParams) SetSlug 

func (o *SQLQueryParams) SetSlug(slug string)

SetSlug adds the slug to the sql query params

func (*SQLQueryParams) SetTimeout 

func (o *SQLQueryParams) SetTimeout(timeout time.Duration)

SetTimeout adds the timeout to the sql query params

func (*SQLQueryParams) WithContext 

func (o *SQLQueryParams) WithContext(ctx context.Context) *SQLQueryParams

WithContext adds the context to the sql query params

func (*SQLQueryParams) WithDefaults 

func (o *SQLQueryParams) WithDefaults() *SQLQueryParams

WithDefaults hydrates default values in the sql query params (not the query body).

All values with no default are reset to their zero value.

func (*SQLQueryParams) WithHTTPClient 

func (o *SQLQueryParams) WithHTTPClient(client *http.Client) *SQLQueryParams

WithHTTPClient adds the HTTPClient to the sql query params

func (*SQLQueryParams) WithSlug 

func (o *SQLQueryParams) WithSlug(slug string) *SQLQueryParams

WithSlug adds the slug to the sql query params

func (*SQLQueryParams) WithTimeout 

func (o *SQLQueryParams) WithTimeout(timeout time.Duration) *SQLQueryParams

WithTimeout adds the timeout to the sql query params

func (*SQLQueryParams) WriteToRequest 

func (o *SQLQueryParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

WriteToRequest writes these params to a swagger request

type SQLQueryReader 

type SQLQueryReader struct {
	// contains filtered or unexported fields
}

SQLQueryReader is a Reader for the SQLQuery structure.

func (*SQLQueryReader) ReadResponse 

func (o *SQLQueryReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

ReadResponse reads a server response into the received o.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.