query

package
v0.0.0-...-9dad3f6 Latest Latest
Warning

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

 Go to latest Published: Dec 3, 2023 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 handles this case 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 handles this case 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 values initialized.

func NewAllRunningQueriesParamsWithContext 

func NewAllRunningQueriesParamsWithContext(ctx context.Context) *AllRunningQueriesParams

NewAllRunningQueriesParamsWithContext creates a new AllRunningQueriesParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 New 

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

New creates a new query API client.

func (*Client) AllRunningQueries 

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

AllRunningQueries gets all running queries

Get information about all running queries.

func (*Client) CreateMergeQuery 

func (a *Client) CreateMergeQuery(params *CreateMergeQueryParams) (*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) (*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) (*CreateQueryTaskOK, error)

CreateQueryTask runs query async

### Run a saved query asynchronously.

Runs a previously created query asynchronously. Returns a Query Task ID which can be used to fetch the results from the Query Tasks results endpoint.

func (*Client) CreateSQLQuery 

func (a *Client) CreateSQLQuery(params *CreateSQLQueryParams) (*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) (*KillQueryNoContent, error)

KillQuery kills running query

Kill a query with a specific query_task_id.

func (*Client) MergeQuery 

func (a *Client) MergeQuery(params *MergeQueryParams) (*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) (*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) (*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) (*QueryTaskOK, error)

QueryTask gets async query info

Returns information about a Query Task.

Query Tasks are generated by running queries asynchronously. They are represented by a GUID returned from one of the async query endpoints.

func (*Client) QueryTaskMultiResults 

func (a *Client) QueryTaskMultiResults(params *QueryTaskMultiResultsParams) (*QueryTaskMultiResultsOK, error)

QueryTaskMultiResults gets multiple async query results

Fetch the results of multiple async Query Tasks in one response.

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) (*QueryTaskResultsOK, *QueryTaskResultsNoContent, error)

QueryTaskResults gets async query results

Returns the results of an async Query Task if the query has completed.

func (*Client) RunInlineQuery 

func (a *Client) RunInlineQuery(params *RunInlineQueryParams) (*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) (*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) (*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) (*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 callible 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) (*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 CreateMergeQueryBadRequest 

type CreateMergeQueryBadRequest struct {
	Payload *models.Error
}

CreateMergeQueryBadRequest handles this case 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 handles this case 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 handles this case 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 handles this case 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 values initialized.

func NewCreateMergeQueryParamsWithContext 

func NewCreateMergeQueryParamsWithContext(ctx context.Context) *CreateMergeQueryParams

NewCreateMergeQueryParamsWithContext creates a new CreateMergeQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 CreateMergeQueryUnprocessableEntity 

type CreateMergeQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}

CreateMergeQueryUnprocessableEntity handles this case 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 handles this case 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 handles this case 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 handles this case 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 handles this case 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 values initialized.

func NewCreateQueryParamsWithContext 

func NewCreateQueryParamsWithContext(ctx context.Context) *CreateQueryParams

NewCreateQueryParamsWithContext creates a new CreateQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 handles this case 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 handles this case 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 handles this case 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 handles this case 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.

	*/
	ImageHeight *int64
	/*ImageWidth
	  Render width for image formats.

	*/
	ImageWidth *int64
	/*Limit
	  Row limit (may override the limit in the saved query).

	*/
	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 values initialized.

func NewCreateQueryTaskParamsWithContext 

func NewCreateQueryTaskParamsWithContext(ctx context.Context) *CreateQueryTaskParams

NewCreateQueryTaskParamsWithContext creates a new CreateQueryTaskParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 CreateQueryTaskUnprocessableEntity 

type CreateQueryTaskUnprocessableEntity struct {
	Payload *models.ValidationError
}

CreateQueryTaskUnprocessableEntity handles this case 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 CreateQueryUnprocessableEntity 

type CreateQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}

CreateQueryUnprocessableEntity handles this case 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 handles this case 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 CreateSQLQueryNotFound 

type CreateSQLQueryNotFound struct {
	Payload *models.Error
}

CreateSQLQueryNotFound handles this case 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 handles this case 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 values initialized.

func NewCreateSQLQueryParamsWithContext 

func NewCreateSQLQueryParamsWithContext(ctx context.Context) *CreateSQLQueryParams

NewCreateSQLQueryParamsWithContext creates a new CreateSQLQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 KillQueryBadRequest 

type KillQueryBadRequest struct {
	Payload *models.Error
}

KillQueryBadRequest handles this case 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 handles this case 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 handles this case 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 values initialized.

func NewKillQueryParamsWithContext 

func NewKillQueryParamsWithContext(ctx context.Context) *KillQueryParams

NewKillQueryParamsWithContext creates a new KillQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 handles this case 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 handles this case 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 handles this case 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 handles this case 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 values initialized.

func NewMergeQueryParamsWithContext 

func NewMergeQueryParamsWithContext(ctx context.Context) *MergeQueryParams

NewMergeQueryParamsWithContext creates a new MergeQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 handles this case 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 handles this case 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 handles this case 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 handles this case 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 values initialized.

func NewQueryForSlugParamsWithContext 

func NewQueryForSlugParamsWithContext(ctx context.Context) *QueryForSlugParams

NewQueryForSlugParamsWithContext creates a new QueryForSlugParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 handles this case 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 handles this case 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

	*/
	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 values initialized.

func NewQueryParamsWithContext 

func NewQueryParamsWithContext(ctx context.Context) *QueryParams

NewQueryParamsWithContext creates a new QueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 handles this case 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 handles this case 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 handles this case 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 handles this case 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 values initialized.

func NewQueryTaskMultiResultsParamsWithContext 

func NewQueryTaskMultiResultsParamsWithContext(ctx context.Context) *QueryTaskMultiResultsParams

NewQueryTaskMultiResultsParamsWithContext creates a new QueryTaskMultiResultsParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 handles this case 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 handles this case 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 values initialized.

func NewQueryTaskParamsWithContext 

func NewQueryTaskParamsWithContext(ctx context.Context) *QueryTaskParams

NewQueryTaskParamsWithContext creates a new QueryTaskParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 handles this case 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 handles this case 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 handles this case 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 map[string]string
}

QueryTaskResultsOK handles this case 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() map[string]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 values initialized.

func NewQueryTaskResultsParamsWithContext 

func NewQueryTaskResultsParamsWithContext(ctx context.Context) *QueryTaskResultsParams

NewQueryTaskResultsParamsWithContext creates a new QueryTaskResultsParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 handles this case 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 handles this case 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 handles this case 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.

	*/
	ImageHeight *int64
	/*ImageWidth
	  Render width for image formats.

	*/
	ImageWidth *int64
	/*Limit
	  Row limit (may override the limit in the saved query).

	*/
	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 values initialized.

func NewRunInlineQueryParamsWithContext 

func NewRunInlineQueryParamsWithContext(ctx context.Context) *RunInlineQueryParams

NewRunInlineQueryParamsWithContext creates a new RunInlineQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 RunQueryBadRequest 

type RunQueryBadRequest struct {
	Payload *models.Error
}

RunQueryBadRequest handles this case 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 handles this case 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 handles this case 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.

	*/
	ImageHeight *int64
	/*ImageWidth
	  Render width for image formats.

	*/
	ImageWidth *int64
	/*Limit
	  Row limit (may override the limit in the saved query).

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

	*/
	PathPrefix *string
	/*QueryID
	  Id of query

	*/
	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 values initialized.

func NewRunQueryParamsWithContext 

func NewRunQueryParamsWithContext(ctx context.Context) *RunQueryParams

NewRunQueryParamsWithContext creates a new RunQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 RunQueryUnprocessableEntity 

type RunQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}

RunQueryUnprocessableEntity handles this case 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 handles this case 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 handles this case 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 handles this case 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: ["json", "json_label", "json_detail", "json_fe", "csv", "html", "md", "txt", "xlsx", "gsxml"]

	*/
	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 values initialized.

func NewRunSQLQueryParamsWithContext 

func NewRunSQLQueryParamsWithContext(ctx context.Context) *RunSQLQueryParams

NewRunSQLQueryParamsWithContext creates a new RunSQLQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 RunSQLQueryUnprocessableEntity 

type RunSQLQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}

RunSQLQueryUnprocessableEntity handles this case 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 handles this case 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 handles this case 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 handles this case 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 values initialized.

func NewRunURLEncodedQueryParamsWithContext 

func NewRunURLEncodedQueryParamsWithContext(ctx context.Context) *RunURLEncodedQueryParams

NewRunURLEncodedQueryParamsWithContext creates a new RunURLEncodedQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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 RunURLEncodedQueryUnprocessableEntity 

type RunURLEncodedQueryUnprocessableEntity struct {
	Payload *models.ValidationError
}

RunURLEncodedQueryUnprocessableEntity handles this case 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 handles this case 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 handles this case 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 handles this case 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 values initialized.

func NewSQLQueryParamsWithContext 

func NewSQLQueryParamsWithContext(ctx context.Context) *SQLQueryParams

NewSQLQueryParamsWithContext creates a new SQLQueryParams object with the default values initialized, and 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 default values initialized, and 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 default values initialized, and 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) 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) 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.