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 }