bitbucket.org/Aishee/synsec@v0.0.0-20210414005726-236fc01a153d/pkg/database/ent/machine_query.go (about)

     1  // Code generated by entc, DO NOT EDIT.
     2  
     3  package ent
     4  
     5  import (
     6  	"context"
     7  	"database/sql/driver"
     8  	"errors"
     9  	"fmt"
    10  	"math"
    11  
    12  	"entgo.io/ent/dialect/sql"
    13  	"entgo.io/ent/dialect/sql/sqlgraph"
    14  	"entgo.io/ent/schema/field"
    15  	"bitbucket.org/Aishee/synsec/pkg/database/ent/alert"
    16  	"bitbucket.org/Aishee/synsec/pkg/database/ent/machine"
    17  	"bitbucket.org/Aishee/synsec/pkg/database/ent/predicate"
    18  )
    19  
    20  // MachineQuery is the builder for querying Machine entities.
    21  type MachineQuery struct {
    22  	config
    23  	limit      *int
    24  	offset     *int
    25  	order      []OrderFunc
    26  	fields     []string
    27  	predicates []predicate.Machine
    28  	// eager-loading edges.
    29  	withAlerts *AlertQuery
    30  	// intermediate query (i.e. traversal path).
    31  	sql  *sql.Selector
    32  	path func(context.Context) (*sql.Selector, error)
    33  }
    34  
    35  // Where adds a new predicate for the MachineQuery builder.
    36  func (mq *MachineQuery) Where(ps ...predicate.Machine) *MachineQuery {
    37  	mq.predicates = append(mq.predicates, ps...)
    38  	return mq
    39  }
    40  
    41  // Limit adds a limit step to the query.
    42  func (mq *MachineQuery) Limit(limit int) *MachineQuery {
    43  	mq.limit = &limit
    44  	return mq
    45  }
    46  
    47  // Offset adds an offset step to the query.
    48  func (mq *MachineQuery) Offset(offset int) *MachineQuery {
    49  	mq.offset = &offset
    50  	return mq
    51  }
    52  
    53  // Order adds an order step to the query.
    54  func (mq *MachineQuery) Order(o ...OrderFunc) *MachineQuery {
    55  	mq.order = append(mq.order, o...)
    56  	return mq
    57  }
    58  
    59  // QueryAlerts chains the current query on the "alerts" edge.
    60  func (mq *MachineQuery) QueryAlerts() *AlertQuery {
    61  	query := &AlertQuery{config: mq.config}
    62  	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
    63  		if err := mq.prepareQuery(ctx); err != nil {
    64  			return nil, err
    65  		}
    66  		selector := mq.sqlQuery(ctx)
    67  		if err := selector.Err(); err != nil {
    68  			return nil, err
    69  		}
    70  		step := sqlgraph.NewStep(
    71  			sqlgraph.From(machine.Table, machine.FieldID, selector),
    72  			sqlgraph.To(alert.Table, alert.FieldID),
    73  			sqlgraph.Edge(sqlgraph.O2M, false, machine.AlertsTable, machine.AlertsColumn),
    74  		)
    75  		fromU = sqlgraph.SetNeighbors(mq.driver.Dialect(), step)
    76  		return fromU, nil
    77  	}
    78  	return query
    79  }
    80  
    81  // First returns the first Machine entity from the query.
    82  // Returns a *NotFoundError when no Machine was found.
    83  func (mq *MachineQuery) First(ctx context.Context) (*Machine, error) {
    84  	nodes, err := mq.Limit(1).All(ctx)
    85  	if err != nil {
    86  		return nil, err
    87  	}
    88  	if len(nodes) == 0 {
    89  		return nil, &NotFoundError{machine.Label}
    90  	}
    91  	return nodes[0], nil
    92  }
    93  
    94  // FirstX is like First, but panics if an error occurs.
    95  func (mq *MachineQuery) FirstX(ctx context.Context) *Machine {
    96  	node, err := mq.First(ctx)
    97  	if err != nil && !IsNotFound(err) {
    98  		panic(err)
    99  	}
   100  	return node
   101  }
   102  
   103  // FirstID returns the first Machine ID from the query.
   104  // Returns a *NotFoundError when no Machine ID was found.
   105  func (mq *MachineQuery) FirstID(ctx context.Context) (id int, err error) {
   106  	var ids []int
   107  	if ids, err = mq.Limit(1).IDs(ctx); err != nil {
   108  		return
   109  	}
   110  	if len(ids) == 0 {
   111  		err = &NotFoundError{machine.Label}
   112  		return
   113  	}
   114  	return ids[0], nil
   115  }
   116  
   117  // FirstIDX is like FirstID, but panics if an error occurs.
   118  func (mq *MachineQuery) FirstIDX(ctx context.Context) int {
   119  	id, err := mq.FirstID(ctx)
   120  	if err != nil && !IsNotFound(err) {
   121  		panic(err)
   122  	}
   123  	return id
   124  }
   125  
   126  // Only returns a single Machine entity found by the query, ensuring it only returns one.
   127  // Returns a *NotSingularError when exactly one Machine entity is not found.
   128  // Returns a *NotFoundError when no Machine entities are found.
   129  func (mq *MachineQuery) Only(ctx context.Context) (*Machine, error) {
   130  	nodes, err := mq.Limit(2).All(ctx)
   131  	if err != nil {
   132  		return nil, err
   133  	}
   134  	switch len(nodes) {
   135  	case 1:
   136  		return nodes[0], nil
   137  	case 0:
   138  		return nil, &NotFoundError{machine.Label}
   139  	default:
   140  		return nil, &NotSingularError{machine.Label}
   141  	}
   142  }
   143  
   144  // OnlyX is like Only, but panics if an error occurs.
   145  func (mq *MachineQuery) OnlyX(ctx context.Context) *Machine {
   146  	node, err := mq.Only(ctx)
   147  	if err != nil {
   148  		panic(err)
   149  	}
   150  	return node
   151  }
   152  
   153  // OnlyID is like Only, but returns the only Machine ID in the query.
   154  // Returns a *NotSingularError when exactly one Machine ID is not found.
   155  // Returns a *NotFoundError when no entities are found.
   156  func (mq *MachineQuery) OnlyID(ctx context.Context) (id int, err error) {
   157  	var ids []int
   158  	if ids, err = mq.Limit(2).IDs(ctx); err != nil {
   159  		return
   160  	}
   161  	switch len(ids) {
   162  	case 1:
   163  		id = ids[0]
   164  	case 0:
   165  		err = &NotFoundError{machine.Label}
   166  	default:
   167  		err = &NotSingularError{machine.Label}
   168  	}
   169  	return
   170  }
   171  
   172  // OnlyIDX is like OnlyID, but panics if an error occurs.
   173  func (mq *MachineQuery) OnlyIDX(ctx context.Context) int {
   174  	id, err := mq.OnlyID(ctx)
   175  	if err != nil {
   176  		panic(err)
   177  	}
   178  	return id
   179  }
   180  
   181  // All executes the query and returns a list of Machines.
   182  func (mq *MachineQuery) All(ctx context.Context) ([]*Machine, error) {
   183  	if err := mq.prepareQuery(ctx); err != nil {
   184  		return nil, err
   185  	}
   186  	return mq.sqlAll(ctx)
   187  }
   188  
   189  // AllX is like All, but panics if an error occurs.
   190  func (mq *MachineQuery) AllX(ctx context.Context) []*Machine {
   191  	nodes, err := mq.All(ctx)
   192  	if err != nil {
   193  		panic(err)
   194  	}
   195  	return nodes
   196  }
   197  
   198  // IDs executes the query and returns a list of Machine IDs.
   199  func (mq *MachineQuery) IDs(ctx context.Context) ([]int, error) {
   200  	var ids []int
   201  	if err := mq.Select(machine.FieldID).Scan(ctx, &ids); err != nil {
   202  		return nil, err
   203  	}
   204  	return ids, nil
   205  }
   206  
   207  // IDsX is like IDs, but panics if an error occurs.
   208  func (mq *MachineQuery) IDsX(ctx context.Context) []int {
   209  	ids, err := mq.IDs(ctx)
   210  	if err != nil {
   211  		panic(err)
   212  	}
   213  	return ids
   214  }
   215  
   216  // Count returns the count of the given query.
   217  func (mq *MachineQuery) Count(ctx context.Context) (int, error) {
   218  	if err := mq.prepareQuery(ctx); err != nil {
   219  		return 0, err
   220  	}
   221  	return mq.sqlCount(ctx)
   222  }
   223  
   224  // CountX is like Count, but panics if an error occurs.
   225  func (mq *MachineQuery) CountX(ctx context.Context) int {
   226  	count, err := mq.Count(ctx)
   227  	if err != nil {
   228  		panic(err)
   229  	}
   230  	return count
   231  }
   232  
   233  // Exist returns true if the query has elements in the graph.
   234  func (mq *MachineQuery) Exist(ctx context.Context) (bool, error) {
   235  	if err := mq.prepareQuery(ctx); err != nil {
   236  		return false, err
   237  	}
   238  	return mq.sqlExist(ctx)
   239  }
   240  
   241  // ExistX is like Exist, but panics if an error occurs.
   242  func (mq *MachineQuery) ExistX(ctx context.Context) bool {
   243  	exist, err := mq.Exist(ctx)
   244  	if err != nil {
   245  		panic(err)
   246  	}
   247  	return exist
   248  }
   249  
   250  // Clone returns a duplicate of the MachineQuery builder, including all associated steps. It can be
   251  // used to prepare common query builders and use them differently after the clone is made.
   252  func (mq *MachineQuery) Clone() *MachineQuery {
   253  	if mq == nil {
   254  		return nil
   255  	}
   256  	return &MachineQuery{
   257  		config:     mq.config,
   258  		limit:      mq.limit,
   259  		offset:     mq.offset,
   260  		order:      append([]OrderFunc{}, mq.order...),
   261  		predicates: append([]predicate.Machine{}, mq.predicates...),
   262  		withAlerts: mq.withAlerts.Clone(),
   263  		// clone intermediate query.
   264  		sql:  mq.sql.Clone(),
   265  		path: mq.path,
   266  	}
   267  }
   268  
   269  // WithAlerts tells the query-builder to eager-load the nodes that are connected to
   270  // the "alerts" edge. The optional arguments are used to configure the query builder of the edge.
   271  func (mq *MachineQuery) WithAlerts(opts ...func(*AlertQuery)) *MachineQuery {
   272  	query := &AlertQuery{config: mq.config}
   273  	for _, opt := range opts {
   274  		opt(query)
   275  	}
   276  	mq.withAlerts = query
   277  	return mq
   278  }
   279  
   280  // GroupBy is used to group vertices by one or more fields/columns.
   281  // It is often used with aggregate functions, like: count, max, mean, min, sum.
   282  //
   283  // Example:
   284  //
   285  //	var v []struct {
   286  //		CreatedAt time.Time `json:"created_at,omitempty"`
   287  //		Count int `json:"count,omitempty"`
   288  //	}
   289  //
   290  //	client.Machine.Query().
   291  //		GroupBy(machine.FieldCreatedAt).
   292  //		Aggregate(ent.Count()).
   293  //		Scan(ctx, &v)
   294  //
   295  func (mq *MachineQuery) GroupBy(field string, fields ...string) *MachineGroupBy {
   296  	group := &MachineGroupBy{config: mq.config}
   297  	group.fields = append([]string{field}, fields...)
   298  	group.path = func(ctx context.Context) (prev *sql.Selector, err error) {
   299  		if err := mq.prepareQuery(ctx); err != nil {
   300  			return nil, err
   301  		}
   302  		return mq.sqlQuery(ctx), nil
   303  	}
   304  	return group
   305  }
   306  
   307  // Select allows the selection one or more fields/columns for the given query,
   308  // instead of selecting all fields in the entity.
   309  //
   310  // Example:
   311  //
   312  //	var v []struct {
   313  //		CreatedAt time.Time `json:"created_at,omitempty"`
   314  //	}
   315  //
   316  //	client.Machine.Query().
   317  //		Select(machine.FieldCreatedAt).
   318  //		Scan(ctx, &v)
   319  //
   320  func (mq *MachineQuery) Select(field string, fields ...string) *MachineSelect {
   321  	mq.fields = append([]string{field}, fields...)
   322  	return &MachineSelect{MachineQuery: mq}
   323  }
   324  
   325  func (mq *MachineQuery) prepareQuery(ctx context.Context) error {
   326  	for _, f := range mq.fields {
   327  		if !machine.ValidColumn(f) {
   328  			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
   329  		}
   330  	}
   331  	if mq.path != nil {
   332  		prev, err := mq.path(ctx)
   333  		if err != nil {
   334  			return err
   335  		}
   336  		mq.sql = prev
   337  	}
   338  	return nil
   339  }
   340  
   341  func (mq *MachineQuery) sqlAll(ctx context.Context) ([]*Machine, error) {
   342  	var (
   343  		nodes       = []*Machine{}
   344  		_spec       = mq.querySpec()
   345  		loadedTypes = [1]bool{
   346  			mq.withAlerts != nil,
   347  		}
   348  	)
   349  	_spec.ScanValues = func(columns []string) ([]interface{}, error) {
   350  		node := &Machine{config: mq.config}
   351  		nodes = append(nodes, node)
   352  		return node.scanValues(columns)
   353  	}
   354  	_spec.Assign = func(columns []string, values []interface{}) error {
   355  		if len(nodes) == 0 {
   356  			return fmt.Errorf("ent: Assign called without calling ScanValues")
   357  		}
   358  		node := nodes[len(nodes)-1]
   359  		node.Edges.loadedTypes = loadedTypes
   360  		return node.assignValues(columns, values)
   361  	}
   362  	if err := sqlgraph.QueryNodes(ctx, mq.driver, _spec); err != nil {
   363  		return nil, err
   364  	}
   365  	if len(nodes) == 0 {
   366  		return nodes, nil
   367  	}
   368  
   369  	if query := mq.withAlerts; query != nil {
   370  		fks := make([]driver.Value, 0, len(nodes))
   371  		nodeids := make(map[int]*Machine)
   372  		for i := range nodes {
   373  			fks = append(fks, nodes[i].ID)
   374  			nodeids[nodes[i].ID] = nodes[i]
   375  			nodes[i].Edges.Alerts = []*Alert{}
   376  		}
   377  		query.withFKs = true
   378  		query.Where(predicate.Alert(func(s *sql.Selector) {
   379  			s.Where(sql.InValues(machine.AlertsColumn, fks...))
   380  		}))
   381  		neighbors, err := query.All(ctx)
   382  		if err != nil {
   383  			return nil, err
   384  		}
   385  		for _, n := range neighbors {
   386  			fk := n.machine_alerts
   387  			if fk == nil {
   388  				return nil, fmt.Errorf(`foreign-key "machine_alerts" is nil for node %v`, n.ID)
   389  			}
   390  			node, ok := nodeids[*fk]
   391  			if !ok {
   392  				return nil, fmt.Errorf(`unexpected foreign-key "machine_alerts" returned %v for node %v`, *fk, n.ID)
   393  			}
   394  			node.Edges.Alerts = append(node.Edges.Alerts, n)
   395  		}
   396  	}
   397  
   398  	return nodes, nil
   399  }
   400  
   401  func (mq *MachineQuery) sqlCount(ctx context.Context) (int, error) {
   402  	_spec := mq.querySpec()
   403  	return sqlgraph.CountNodes(ctx, mq.driver, _spec)
   404  }
   405  
   406  func (mq *MachineQuery) sqlExist(ctx context.Context) (bool, error) {
   407  	n, err := mq.sqlCount(ctx)
   408  	if err != nil {
   409  		return false, fmt.Errorf("ent: check existence: %w", err)
   410  	}
   411  	return n > 0, nil
   412  }
   413  
   414  func (mq *MachineQuery) querySpec() *sqlgraph.QuerySpec {
   415  	_spec := &sqlgraph.QuerySpec{
   416  		Node: &sqlgraph.NodeSpec{
   417  			Table:   machine.Table,
   418  			Columns: machine.Columns,
   419  			ID: &sqlgraph.FieldSpec{
   420  				Type:   field.TypeInt,
   421  				Column: machine.FieldID,
   422  			},
   423  		},
   424  		From:   mq.sql,
   425  		Unique: true,
   426  	}
   427  	if fields := mq.fields; len(fields) > 0 {
   428  		_spec.Node.Columns = make([]string, 0, len(fields))
   429  		_spec.Node.Columns = append(_spec.Node.Columns, machine.FieldID)
   430  		for i := range fields {
   431  			if fields[i] != machine.FieldID {
   432  				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
   433  			}
   434  		}
   435  	}
   436  	if ps := mq.predicates; len(ps) > 0 {
   437  		_spec.Predicate = func(selector *sql.Selector) {
   438  			for i := range ps {
   439  				ps[i](selector)
   440  			}
   441  		}
   442  	}
   443  	if limit := mq.limit; limit != nil {
   444  		_spec.Limit = *limit
   445  	}
   446  	if offset := mq.offset; offset != nil {
   447  		_spec.Offset = *offset
   448  	}
   449  	if ps := mq.order; len(ps) > 0 {
   450  		_spec.Order = func(selector *sql.Selector) {
   451  			for i := range ps {
   452  				ps[i](selector, machine.ValidColumn)
   453  			}
   454  		}
   455  	}
   456  	return _spec
   457  }
   458  
   459  func (mq *MachineQuery) sqlQuery(ctx context.Context) *sql.Selector {
   460  	builder := sql.Dialect(mq.driver.Dialect())
   461  	t1 := builder.Table(machine.Table)
   462  	selector := builder.Select(t1.Columns(machine.Columns...)...).From(t1)
   463  	if mq.sql != nil {
   464  		selector = mq.sql
   465  		selector.Select(selector.Columns(machine.Columns...)...)
   466  	}
   467  	for _, p := range mq.predicates {
   468  		p(selector)
   469  	}
   470  	for _, p := range mq.order {
   471  		p(selector, machine.ValidColumn)
   472  	}
   473  	if offset := mq.offset; offset != nil {
   474  		// limit is mandatory for offset clause. We start
   475  		// with default value, and override it below if needed.
   476  		selector.Offset(*offset).Limit(math.MaxInt32)
   477  	}
   478  	if limit := mq.limit; limit != nil {
   479  		selector.Limit(*limit)
   480  	}
   481  	return selector
   482  }
   483  
   484  // MachineGroupBy is the group-by builder for Machine entities.
   485  type MachineGroupBy struct {
   486  	config
   487  	fields []string
   488  	fns    []AggregateFunc
   489  	// intermediate query (i.e. traversal path).
   490  	sql  *sql.Selector
   491  	path func(context.Context) (*sql.Selector, error)
   492  }
   493  
   494  // Aggregate adds the given aggregation functions to the group-by query.
   495  func (mgb *MachineGroupBy) Aggregate(fns ...AggregateFunc) *MachineGroupBy {
   496  	mgb.fns = append(mgb.fns, fns...)
   497  	return mgb
   498  }
   499  
   500  // Scan applies the group-by query and scans the result into the given value.
   501  func (mgb *MachineGroupBy) Scan(ctx context.Context, v interface{}) error {
   502  	query, err := mgb.path(ctx)
   503  	if err != nil {
   504  		return err
   505  	}
   506  	mgb.sql = query
   507  	return mgb.sqlScan(ctx, v)
   508  }
   509  
   510  // ScanX is like Scan, but panics if an error occurs.
   511  func (mgb *MachineGroupBy) ScanX(ctx context.Context, v interface{}) {
   512  	if err := mgb.Scan(ctx, v); err != nil {
   513  		panic(err)
   514  	}
   515  }
   516  
   517  // Strings returns list of strings from group-by.
   518  // It is only allowed when executing a group-by query with one field.
   519  func (mgb *MachineGroupBy) Strings(ctx context.Context) ([]string, error) {
   520  	if len(mgb.fields) > 1 {
   521  		return nil, errors.New("ent: MachineGroupBy.Strings is not achievable when grouping more than 1 field")
   522  	}
   523  	var v []string
   524  	if err := mgb.Scan(ctx, &v); err != nil {
   525  		return nil, err
   526  	}
   527  	return v, nil
   528  }
   529  
   530  // StringsX is like Strings, but panics if an error occurs.
   531  func (mgb *MachineGroupBy) StringsX(ctx context.Context) []string {
   532  	v, err := mgb.Strings(ctx)
   533  	if err != nil {
   534  		panic(err)
   535  	}
   536  	return v
   537  }
   538  
   539  // String returns a single string from a group-by query.
   540  // It is only allowed when executing a group-by query with one field.
   541  func (mgb *MachineGroupBy) String(ctx context.Context) (_ string, err error) {
   542  	var v []string
   543  	if v, err = mgb.Strings(ctx); err != nil {
   544  		return
   545  	}
   546  	switch len(v) {
   547  	case 1:
   548  		return v[0], nil
   549  	case 0:
   550  		err = &NotFoundError{machine.Label}
   551  	default:
   552  		err = fmt.Errorf("ent: MachineGroupBy.Strings returned %d results when one was expected", len(v))
   553  	}
   554  	return
   555  }
   556  
   557  // StringX is like String, but panics if an error occurs.
   558  func (mgb *MachineGroupBy) StringX(ctx context.Context) string {
   559  	v, err := mgb.String(ctx)
   560  	if err != nil {
   561  		panic(err)
   562  	}
   563  	return v
   564  }
   565  
   566  // Ints returns list of ints from group-by.
   567  // It is only allowed when executing a group-by query with one field.
   568  func (mgb *MachineGroupBy) Ints(ctx context.Context) ([]int, error) {
   569  	if len(mgb.fields) > 1 {
   570  		return nil, errors.New("ent: MachineGroupBy.Ints is not achievable when grouping more than 1 field")
   571  	}
   572  	var v []int
   573  	if err := mgb.Scan(ctx, &v); err != nil {
   574  		return nil, err
   575  	}
   576  	return v, nil
   577  }
   578  
   579  // IntsX is like Ints, but panics if an error occurs.
   580  func (mgb *MachineGroupBy) IntsX(ctx context.Context) []int {
   581  	v, err := mgb.Ints(ctx)
   582  	if err != nil {
   583  		panic(err)
   584  	}
   585  	return v
   586  }
   587  
   588  // Int returns a single int from a group-by query.
   589  // It is only allowed when executing a group-by query with one field.
   590  func (mgb *MachineGroupBy) Int(ctx context.Context) (_ int, err error) {
   591  	var v []int
   592  	if v, err = mgb.Ints(ctx); err != nil {
   593  		return
   594  	}
   595  	switch len(v) {
   596  	case 1:
   597  		return v[0], nil
   598  	case 0:
   599  		err = &NotFoundError{machine.Label}
   600  	default:
   601  		err = fmt.Errorf("ent: MachineGroupBy.Ints returned %d results when one was expected", len(v))
   602  	}
   603  	return
   604  }
   605  
   606  // IntX is like Int, but panics if an error occurs.
   607  func (mgb *MachineGroupBy) IntX(ctx context.Context) int {
   608  	v, err := mgb.Int(ctx)
   609  	if err != nil {
   610  		panic(err)
   611  	}
   612  	return v
   613  }
   614  
   615  // Float64s returns list of float64s from group-by.
   616  // It is only allowed when executing a group-by query with one field.
   617  func (mgb *MachineGroupBy) Float64s(ctx context.Context) ([]float64, error) {
   618  	if len(mgb.fields) > 1 {
   619  		return nil, errors.New("ent: MachineGroupBy.Float64s is not achievable when grouping more than 1 field")
   620  	}
   621  	var v []float64
   622  	if err := mgb.Scan(ctx, &v); err != nil {
   623  		return nil, err
   624  	}
   625  	return v, nil
   626  }
   627  
   628  // Float64sX is like Float64s, but panics if an error occurs.
   629  func (mgb *MachineGroupBy) Float64sX(ctx context.Context) []float64 {
   630  	v, err := mgb.Float64s(ctx)
   631  	if err != nil {
   632  		panic(err)
   633  	}
   634  	return v
   635  }
   636  
   637  // Float64 returns a single float64 from a group-by query.
   638  // It is only allowed when executing a group-by query with one field.
   639  func (mgb *MachineGroupBy) Float64(ctx context.Context) (_ float64, err error) {
   640  	var v []float64
   641  	if v, err = mgb.Float64s(ctx); err != nil {
   642  		return
   643  	}
   644  	switch len(v) {
   645  	case 1:
   646  		return v[0], nil
   647  	case 0:
   648  		err = &NotFoundError{machine.Label}
   649  	default:
   650  		err = fmt.Errorf("ent: MachineGroupBy.Float64s returned %d results when one was expected", len(v))
   651  	}
   652  	return
   653  }
   654  
   655  // Float64X is like Float64, but panics if an error occurs.
   656  func (mgb *MachineGroupBy) Float64X(ctx context.Context) float64 {
   657  	v, err := mgb.Float64(ctx)
   658  	if err != nil {
   659  		panic(err)
   660  	}
   661  	return v
   662  }
   663  
   664  // Bools returns list of bools from group-by.
   665  // It is only allowed when executing a group-by query with one field.
   666  func (mgb *MachineGroupBy) Bools(ctx context.Context) ([]bool, error) {
   667  	if len(mgb.fields) > 1 {
   668  		return nil, errors.New("ent: MachineGroupBy.Bools is not achievable when grouping more than 1 field")
   669  	}
   670  	var v []bool
   671  	if err := mgb.Scan(ctx, &v); err != nil {
   672  		return nil, err
   673  	}
   674  	return v, nil
   675  }
   676  
   677  // BoolsX is like Bools, but panics if an error occurs.
   678  func (mgb *MachineGroupBy) BoolsX(ctx context.Context) []bool {
   679  	v, err := mgb.Bools(ctx)
   680  	if err != nil {
   681  		panic(err)
   682  	}
   683  	return v
   684  }
   685  
   686  // Bool returns a single bool from a group-by query.
   687  // It is only allowed when executing a group-by query with one field.
   688  func (mgb *MachineGroupBy) Bool(ctx context.Context) (_ bool, err error) {
   689  	var v []bool
   690  	if v, err = mgb.Bools(ctx); err != nil {
   691  		return
   692  	}
   693  	switch len(v) {
   694  	case 1:
   695  		return v[0], nil
   696  	case 0:
   697  		err = &NotFoundError{machine.Label}
   698  	default:
   699  		err = fmt.Errorf("ent: MachineGroupBy.Bools returned %d results when one was expected", len(v))
   700  	}
   701  	return
   702  }
   703  
   704  // BoolX is like Bool, but panics if an error occurs.
   705  func (mgb *MachineGroupBy) BoolX(ctx context.Context) bool {
   706  	v, err := mgb.Bool(ctx)
   707  	if err != nil {
   708  		panic(err)
   709  	}
   710  	return v
   711  }
   712  
   713  func (mgb *MachineGroupBy) sqlScan(ctx context.Context, v interface{}) error {
   714  	for _, f := range mgb.fields {
   715  		if !machine.ValidColumn(f) {
   716  			return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
   717  		}
   718  	}
   719  	selector := mgb.sqlQuery()
   720  	if err := selector.Err(); err != nil {
   721  		return err
   722  	}
   723  	rows := &sql.Rows{}
   724  	query, args := selector.Query()
   725  	if err := mgb.driver.Query(ctx, query, args, rows); err != nil {
   726  		return err
   727  	}
   728  	defer rows.Close()
   729  	return sql.ScanSlice(rows, v)
   730  }
   731  
   732  func (mgb *MachineGroupBy) sqlQuery() *sql.Selector {
   733  	selector := mgb.sql
   734  	columns := make([]string, 0, len(mgb.fields)+len(mgb.fns))
   735  	columns = append(columns, mgb.fields...)
   736  	for _, fn := range mgb.fns {
   737  		columns = append(columns, fn(selector, machine.ValidColumn))
   738  	}
   739  	return selector.Select(columns...).GroupBy(mgb.fields...)
   740  }
   741  
   742  // MachineSelect is the builder for selecting fields of Machine entities.
   743  type MachineSelect struct {
   744  	*MachineQuery
   745  	// intermediate query (i.e. traversal path).
   746  	sql *sql.Selector
   747  }
   748  
   749  // Scan applies the selector query and scans the result into the given value.
   750  func (ms *MachineSelect) Scan(ctx context.Context, v interface{}) error {
   751  	if err := ms.prepareQuery(ctx); err != nil {
   752  		return err
   753  	}
   754  	ms.sql = ms.MachineQuery.sqlQuery(ctx)
   755  	return ms.sqlScan(ctx, v)
   756  }
   757  
   758  // ScanX is like Scan, but panics if an error occurs.
   759  func (ms *MachineSelect) ScanX(ctx context.Context, v interface{}) {
   760  	if err := ms.Scan(ctx, v); err != nil {
   761  		panic(err)
   762  	}
   763  }
   764  
   765  // Strings returns list of strings from a selector. It is only allowed when selecting one field.
   766  func (ms *MachineSelect) Strings(ctx context.Context) ([]string, error) {
   767  	if len(ms.fields) > 1 {
   768  		return nil, errors.New("ent: MachineSelect.Strings is not achievable when selecting more than 1 field")
   769  	}
   770  	var v []string
   771  	if err := ms.Scan(ctx, &v); err != nil {
   772  		return nil, err
   773  	}
   774  	return v, nil
   775  }
   776  
   777  // StringsX is like Strings, but panics if an error occurs.
   778  func (ms *MachineSelect) StringsX(ctx context.Context) []string {
   779  	v, err := ms.Strings(ctx)
   780  	if err != nil {
   781  		panic(err)
   782  	}
   783  	return v
   784  }
   785  
   786  // String returns a single string from a selector. It is only allowed when selecting one field.
   787  func (ms *MachineSelect) String(ctx context.Context) (_ string, err error) {
   788  	var v []string
   789  	if v, err = ms.Strings(ctx); err != nil {
   790  		return
   791  	}
   792  	switch len(v) {
   793  	case 1:
   794  		return v[0], nil
   795  	case 0:
   796  		err = &NotFoundError{machine.Label}
   797  	default:
   798  		err = fmt.Errorf("ent: MachineSelect.Strings returned %d results when one was expected", len(v))
   799  	}
   800  	return
   801  }
   802  
   803  // StringX is like String, but panics if an error occurs.
   804  func (ms *MachineSelect) StringX(ctx context.Context) string {
   805  	v, err := ms.String(ctx)
   806  	if err != nil {
   807  		panic(err)
   808  	}
   809  	return v
   810  }
   811  
   812  // Ints returns list of ints from a selector. It is only allowed when selecting one field.
   813  func (ms *MachineSelect) Ints(ctx context.Context) ([]int, error) {
   814  	if len(ms.fields) > 1 {
   815  		return nil, errors.New("ent: MachineSelect.Ints is not achievable when selecting more than 1 field")
   816  	}
   817  	var v []int
   818  	if err := ms.Scan(ctx, &v); err != nil {
   819  		return nil, err
   820  	}
   821  	return v, nil
   822  }
   823  
   824  // IntsX is like Ints, but panics if an error occurs.
   825  func (ms *MachineSelect) IntsX(ctx context.Context) []int {
   826  	v, err := ms.Ints(ctx)
   827  	if err != nil {
   828  		panic(err)
   829  	}
   830  	return v
   831  }
   832  
   833  // Int returns a single int from a selector. It is only allowed when selecting one field.
   834  func (ms *MachineSelect) Int(ctx context.Context) (_ int, err error) {
   835  	var v []int
   836  	if v, err = ms.Ints(ctx); err != nil {
   837  		return
   838  	}
   839  	switch len(v) {
   840  	case 1:
   841  		return v[0], nil
   842  	case 0:
   843  		err = &NotFoundError{machine.Label}
   844  	default:
   845  		err = fmt.Errorf("ent: MachineSelect.Ints returned %d results when one was expected", len(v))
   846  	}
   847  	return
   848  }
   849  
   850  // IntX is like Int, but panics if an error occurs.
   851  func (ms *MachineSelect) IntX(ctx context.Context) int {
   852  	v, err := ms.Int(ctx)
   853  	if err != nil {
   854  		panic(err)
   855  	}
   856  	return v
   857  }
   858  
   859  // Float64s returns list of float64s from a selector. It is only allowed when selecting one field.
   860  func (ms *MachineSelect) Float64s(ctx context.Context) ([]float64, error) {
   861  	if len(ms.fields) > 1 {
   862  		return nil, errors.New("ent: MachineSelect.Float64s is not achievable when selecting more than 1 field")
   863  	}
   864  	var v []float64
   865  	if err := ms.Scan(ctx, &v); err != nil {
   866  		return nil, err
   867  	}
   868  	return v, nil
   869  }
   870  
   871  // Float64sX is like Float64s, but panics if an error occurs.
   872  func (ms *MachineSelect) Float64sX(ctx context.Context) []float64 {
   873  	v, err := ms.Float64s(ctx)
   874  	if err != nil {
   875  		panic(err)
   876  	}
   877  	return v
   878  }
   879  
   880  // Float64 returns a single float64 from a selector. It is only allowed when selecting one field.
   881  func (ms *MachineSelect) Float64(ctx context.Context) (_ float64, err error) {
   882  	var v []float64
   883  	if v, err = ms.Float64s(ctx); err != nil {
   884  		return
   885  	}
   886  	switch len(v) {
   887  	case 1:
   888  		return v[0], nil
   889  	case 0:
   890  		err = &NotFoundError{machine.Label}
   891  	default:
   892  		err = fmt.Errorf("ent: MachineSelect.Float64s returned %d results when one was expected", len(v))
   893  	}
   894  	return
   895  }
   896  
   897  // Float64X is like Float64, but panics if an error occurs.
   898  func (ms *MachineSelect) Float64X(ctx context.Context) float64 {
   899  	v, err := ms.Float64(ctx)
   900  	if err != nil {
   901  		panic(err)
   902  	}
   903  	return v
   904  }
   905  
   906  // Bools returns list of bools from a selector. It is only allowed when selecting one field.
   907  func (ms *MachineSelect) Bools(ctx context.Context) ([]bool, error) {
   908  	if len(ms.fields) > 1 {
   909  		return nil, errors.New("ent: MachineSelect.Bools is not achievable when selecting more than 1 field")
   910  	}
   911  	var v []bool
   912  	if err := ms.Scan(ctx, &v); err != nil {
   913  		return nil, err
   914  	}
   915  	return v, nil
   916  }
   917  
   918  // BoolsX is like Bools, but panics if an error occurs.
   919  func (ms *MachineSelect) BoolsX(ctx context.Context) []bool {
   920  	v, err := ms.Bools(ctx)
   921  	if err != nil {
   922  		panic(err)
   923  	}
   924  	return v
   925  }
   926  
   927  // Bool returns a single bool from a selector. It is only allowed when selecting one field.
   928  func (ms *MachineSelect) Bool(ctx context.Context) (_ bool, err error) {
   929  	var v []bool
   930  	if v, err = ms.Bools(ctx); err != nil {
   931  		return
   932  	}
   933  	switch len(v) {
   934  	case 1:
   935  		return v[0], nil
   936  	case 0:
   937  		err = &NotFoundError{machine.Label}
   938  	default:
   939  		err = fmt.Errorf("ent: MachineSelect.Bools returned %d results when one was expected", len(v))
   940  	}
   941  	return
   942  }
   943  
   944  // BoolX is like Bool, but panics if an error occurs.
   945  func (ms *MachineSelect) BoolX(ctx context.Context) bool {
   946  	v, err := ms.Bool(ctx)
   947  	if err != nil {
   948  		panic(err)
   949  	}
   950  	return v
   951  }
   952  
   953  func (ms *MachineSelect) sqlScan(ctx context.Context, v interface{}) error {
   954  	rows := &sql.Rows{}
   955  	query, args := ms.sqlQuery().Query()
   956  	if err := ms.driver.Query(ctx, query, args, rows); err != nil {
   957  		return err
   958  	}
   959  	defer rows.Close()
   960  	return sql.ScanSlice(rows, v)
   961  }
   962  
   963  func (ms *MachineSelect) sqlQuery() sql.Querier {
   964  	selector := ms.sql
   965  	selector.Select(selector.Columns(ms.fields...)...)
   966  	return selector
   967  }