running_queries.go

// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"context"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// RunningQueries running queries
//
// swagger:model RunningQueries
type RunningQueries struct {

	// Cache Key
	// Read Only: true
	CacheKey string `json:"cache_key,omitempty"`

	// Operations the current user is able to perform on this object
	// Read Only: true
	Can map[string]bool `json:"can,omitempty"`

	// Date/Time Query was completed
	// Read Only: true
	CompletedAt string `json:"completed_at,omitempty"`

	// Connection ID
	// Read Only: true
	ConnectionID string `json:"connection_id,omitempty"`

	// Connection
	// Read Only: true
	ConnectionName string `json:"connection_name,omitempty"`

	// Date/Time Query was initiated
	// Read Only: true
	CreatedAt string `json:"created_at,omitempty"`

	// Dialect
	// Read Only: true
	Dialect string `json:"dialect,omitempty"`

	// Unique Id
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Look of query that was run
	// Read Only: true
	Look *LookBasic `json:"look,omitempty"`

	// Additional Information(Error message or verbose status)
	// Read Only: true
	Message string `json:"message,omitempty"`

	// Node Id
	// Read Only: true
	NodeID string `json:"node_id,omitempty"`

	// Query that was run
	// Read Only: true
	Query *Query `json:"query,omitempty"`

	// Query Id
	// Read Only: true
	QueryID string `json:"query_id,omitempty"`

	// ID of a Query Task
	// Read Only: true
	QueryTaskID string `json:"query_task_id,omitempty"`

	// Number of seconds elapsed running the Query
	// Read Only: true
	Runtime float64 `json:"runtime,omitempty"`

	// Slug
	// Read Only: true
	Slug string `json:"slug,omitempty"`

	// Source (look, dashboard, queryrunner, explore, etc.)
	// Read Only: true
	Source string `json:"source,omitempty"`

	// SQL text of the query as run
	// Read Only: true
	SQL string `json:"sql,omitempty"`

	// SQL Query that was run
	// Read Only: true
	SQLQuery *SQLQuery `json:"sql_query,omitempty"`

	// Status description
	// Read Only: true
	Status string `json:"status,omitempty"`

	// User who initiated the query
	// Read Only: true
	User *UserPublic `json:"user,omitempty"`
}

// Validate validates this running queries
func (m *RunningQueries) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateLook(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateQuery(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSQLQuery(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateUser(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *RunningQueries) validateLook(formats strfmt.Registry) error {
	if swag.IsZero(m.Look) { // not required
		return nil
	}

	if m.Look != nil {
		if err := m.Look.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("look")
			}
			return err
		}
	}

	return nil
}

func (m *RunningQueries) validateQuery(formats strfmt.Registry) error {
	if swag.IsZero(m.Query) { // not required
		return nil
	}

	if m.Query != nil {
		if err := m.Query.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("query")
			}
			return err
		}
	}

	return nil
}

func (m *RunningQueries) validateSQLQuery(formats strfmt.Registry) error {
	if swag.IsZero(m.SQLQuery) { // not required
		return nil
	}

	if m.SQLQuery != nil {
		if err := m.SQLQuery.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("sql_query")
			}
			return err
		}
	}

	return nil
}

func (m *RunningQueries) validateUser(formats strfmt.Registry) error {
	if swag.IsZero(m.User) { // not required
		return nil
	}

	if m.User != nil {
		if err := m.User.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("user")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this running queries based on the context it is used
func (m *RunningQueries) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateCacheKey(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCan(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCompletedAt(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateConnectionID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateConnectionName(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCreatedAt(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateDialect(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateLook(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateMessage(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateNodeID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateQuery(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateQueryID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateQueryTaskID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateRuntime(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSlug(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSource(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSQL(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSQLQuery(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateStatus(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateUser(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *RunningQueries) contextValidateCacheKey(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "cache_key", "body", string(m.CacheKey)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateCan(ctx context.Context, formats strfmt.Registry) error {

	return nil
}

func (m *RunningQueries) contextValidateCompletedAt(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "completed_at", "body", string(m.CompletedAt)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateConnectionID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "connection_id", "body", string(m.ConnectionID)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateConnectionName(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "connection_name", "body", string(m.ConnectionName)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateCreatedAt(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "created_at", "body", string(m.CreatedAt)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateDialect(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "dialect", "body", string(m.Dialect)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "id", "body", int64(m.ID)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateLook(ctx context.Context, formats strfmt.Registry) error {

	if m.Look != nil {
		if err := m.Look.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("look")
			}
			return err
		}
	}

	return nil
}

func (m *RunningQueries) contextValidateMessage(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "message", "body", string(m.Message)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateNodeID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "node_id", "body", string(m.NodeID)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateQuery(ctx context.Context, formats strfmt.Registry) error {

	if m.Query != nil {
		if err := m.Query.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("query")
			}
			return err
		}
	}

	return nil
}

func (m *RunningQueries) contextValidateQueryID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "query_id", "body", string(m.QueryID)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateQueryTaskID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "query_task_id", "body", string(m.QueryTaskID)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateRuntime(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "runtime", "body", float64(m.Runtime)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateSlug(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "slug", "body", string(m.Slug)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateSource(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "source", "body", string(m.Source)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateSQL(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "sql", "body", string(m.SQL)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateSQLQuery(ctx context.Context, formats strfmt.Registry) error {

	if m.SQLQuery != nil {
		if err := m.SQLQuery.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("sql_query")
			}
			return err
		}
	}

	return nil
}

func (m *RunningQueries) contextValidateStatus(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "status", "body", string(m.Status)); err != nil {
		return err
	}

	return nil
}

func (m *RunningQueries) contextValidateUser(ctx context.Context, formats strfmt.Registry) error {

	if m.User != nil {
		if err := m.User.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("user")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *RunningQueries) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *RunningQueries) UnmarshalBinary(b []byte) error {
	var res RunningQueries
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}