github.com/iasthc/atlas/cmd/atlas@v0.0.0-20230523071841-73246df3f88d/internal/migrate/ent/revision/where.go (about) 1 // Copyright 2021-present The Atlas Authors. All rights reserved. 2 // This source code is licensed under the Apache 2.0 license found 3 // in the LICENSE file in the root directory of this source tree. 4 5 // Code generated by entc, DO NOT EDIT. 6 7 package revision 8 9 import ( 10 "time" 11 12 "github.com/iasthc/atlas/cmd/atlas/internal/migrate/ent/predicate" 13 "github.com/iasthc/atlas/sql/migrate" 14 "entgo.io/ent/dialect/sql" 15 ) 16 17 // ID filters vertices based on their ID field. 18 func ID(id string) predicate.Revision { 19 return predicate.Revision(sql.FieldEQ(FieldID, id)) 20 } 21 22 // IDEQ applies the EQ predicate on the ID field. 23 func IDEQ(id string) predicate.Revision { 24 return predicate.Revision(sql.FieldEQ(FieldID, id)) 25 } 26 27 // IDNEQ applies the NEQ predicate on the ID field. 28 func IDNEQ(id string) predicate.Revision { 29 return predicate.Revision(sql.FieldNEQ(FieldID, id)) 30 } 31 32 // IDIn applies the In predicate on the ID field. 33 func IDIn(ids ...string) predicate.Revision { 34 return predicate.Revision(sql.FieldIn(FieldID, ids...)) 35 } 36 37 // IDNotIn applies the NotIn predicate on the ID field. 38 func IDNotIn(ids ...string) predicate.Revision { 39 return predicate.Revision(sql.FieldNotIn(FieldID, ids...)) 40 } 41 42 // IDGT applies the GT predicate on the ID field. 43 func IDGT(id string) predicate.Revision { 44 return predicate.Revision(sql.FieldGT(FieldID, id)) 45 } 46 47 // IDGTE applies the GTE predicate on the ID field. 48 func IDGTE(id string) predicate.Revision { 49 return predicate.Revision(sql.FieldGTE(FieldID, id)) 50 } 51 52 // IDLT applies the LT predicate on the ID field. 53 func IDLT(id string) predicate.Revision { 54 return predicate.Revision(sql.FieldLT(FieldID, id)) 55 } 56 57 // IDLTE applies the LTE predicate on the ID field. 58 func IDLTE(id string) predicate.Revision { 59 return predicate.Revision(sql.FieldLTE(FieldID, id)) 60 } 61 62 // IDEqualFold applies the EqualFold predicate on the ID field. 63 func IDEqualFold(id string) predicate.Revision { 64 return predicate.Revision(sql.FieldEqualFold(FieldID, id)) 65 } 66 67 // IDContainsFold applies the ContainsFold predicate on the ID field. 68 func IDContainsFold(id string) predicate.Revision { 69 return predicate.Revision(sql.FieldContainsFold(FieldID, id)) 70 } 71 72 // Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ. 73 func Description(v string) predicate.Revision { 74 return predicate.Revision(sql.FieldEQ(FieldDescription, v)) 75 } 76 77 // Type applies equality check predicate on the "type" field. It's identical to TypeEQ. 78 func Type(v migrate.RevisionType) predicate.Revision { 79 vc := uint(v) 80 return predicate.Revision(sql.FieldEQ(FieldType, vc)) 81 } 82 83 // Applied applies equality check predicate on the "applied" field. It's identical to AppliedEQ. 84 func Applied(v int) predicate.Revision { 85 return predicate.Revision(sql.FieldEQ(FieldApplied, v)) 86 } 87 88 // Total applies equality check predicate on the "total" field. It's identical to TotalEQ. 89 func Total(v int) predicate.Revision { 90 return predicate.Revision(sql.FieldEQ(FieldTotal, v)) 91 } 92 93 // ExecutedAt applies equality check predicate on the "executed_at" field. It's identical to ExecutedAtEQ. 94 func ExecutedAt(v time.Time) predicate.Revision { 95 return predicate.Revision(sql.FieldEQ(FieldExecutedAt, v)) 96 } 97 98 // ExecutionTime applies equality check predicate on the "execution_time" field. It's identical to ExecutionTimeEQ. 99 func ExecutionTime(v time.Duration) predicate.Revision { 100 vc := int64(v) 101 return predicate.Revision(sql.FieldEQ(FieldExecutionTime, vc)) 102 } 103 104 // Error applies equality check predicate on the "error" field. It's identical to ErrorEQ. 105 func Error(v string) predicate.Revision { 106 return predicate.Revision(sql.FieldEQ(FieldError, v)) 107 } 108 109 // ErrorStmt applies equality check predicate on the "error_stmt" field. It's identical to ErrorStmtEQ. 110 func ErrorStmt(v string) predicate.Revision { 111 return predicate.Revision(sql.FieldEQ(FieldErrorStmt, v)) 112 } 113 114 // Hash applies equality check predicate on the "hash" field. It's identical to HashEQ. 115 func Hash(v string) predicate.Revision { 116 return predicate.Revision(sql.FieldEQ(FieldHash, v)) 117 } 118 119 // OperatorVersion applies equality check predicate on the "operator_version" field. It's identical to OperatorVersionEQ. 120 func OperatorVersion(v string) predicate.Revision { 121 return predicate.Revision(sql.FieldEQ(FieldOperatorVersion, v)) 122 } 123 124 // DescriptionEQ applies the EQ predicate on the "description" field. 125 func DescriptionEQ(v string) predicate.Revision { 126 return predicate.Revision(sql.FieldEQ(FieldDescription, v)) 127 } 128 129 // DescriptionNEQ applies the NEQ predicate on the "description" field. 130 func DescriptionNEQ(v string) predicate.Revision { 131 return predicate.Revision(sql.FieldNEQ(FieldDescription, v)) 132 } 133 134 // DescriptionIn applies the In predicate on the "description" field. 135 func DescriptionIn(vs ...string) predicate.Revision { 136 return predicate.Revision(sql.FieldIn(FieldDescription, vs...)) 137 } 138 139 // DescriptionNotIn applies the NotIn predicate on the "description" field. 140 func DescriptionNotIn(vs ...string) predicate.Revision { 141 return predicate.Revision(sql.FieldNotIn(FieldDescription, vs...)) 142 } 143 144 // DescriptionGT applies the GT predicate on the "description" field. 145 func DescriptionGT(v string) predicate.Revision { 146 return predicate.Revision(sql.FieldGT(FieldDescription, v)) 147 } 148 149 // DescriptionGTE applies the GTE predicate on the "description" field. 150 func DescriptionGTE(v string) predicate.Revision { 151 return predicate.Revision(sql.FieldGTE(FieldDescription, v)) 152 } 153 154 // DescriptionLT applies the LT predicate on the "description" field. 155 func DescriptionLT(v string) predicate.Revision { 156 return predicate.Revision(sql.FieldLT(FieldDescription, v)) 157 } 158 159 // DescriptionLTE applies the LTE predicate on the "description" field. 160 func DescriptionLTE(v string) predicate.Revision { 161 return predicate.Revision(sql.FieldLTE(FieldDescription, v)) 162 } 163 164 // DescriptionContains applies the Contains predicate on the "description" field. 165 func DescriptionContains(v string) predicate.Revision { 166 return predicate.Revision(sql.FieldContains(FieldDescription, v)) 167 } 168 169 // DescriptionHasPrefix applies the HasPrefix predicate on the "description" field. 170 func DescriptionHasPrefix(v string) predicate.Revision { 171 return predicate.Revision(sql.FieldHasPrefix(FieldDescription, v)) 172 } 173 174 // DescriptionHasSuffix applies the HasSuffix predicate on the "description" field. 175 func DescriptionHasSuffix(v string) predicate.Revision { 176 return predicate.Revision(sql.FieldHasSuffix(FieldDescription, v)) 177 } 178 179 // DescriptionEqualFold applies the EqualFold predicate on the "description" field. 180 func DescriptionEqualFold(v string) predicate.Revision { 181 return predicate.Revision(sql.FieldEqualFold(FieldDescription, v)) 182 } 183 184 // DescriptionContainsFold applies the ContainsFold predicate on the "description" field. 185 func DescriptionContainsFold(v string) predicate.Revision { 186 return predicate.Revision(sql.FieldContainsFold(FieldDescription, v)) 187 } 188 189 // TypeEQ applies the EQ predicate on the "type" field. 190 func TypeEQ(v migrate.RevisionType) predicate.Revision { 191 vc := uint(v) 192 return predicate.Revision(sql.FieldEQ(FieldType, vc)) 193 } 194 195 // TypeNEQ applies the NEQ predicate on the "type" field. 196 func TypeNEQ(v migrate.RevisionType) predicate.Revision { 197 vc := uint(v) 198 return predicate.Revision(sql.FieldNEQ(FieldType, vc)) 199 } 200 201 // TypeIn applies the In predicate on the "type" field. 202 func TypeIn(vs ...migrate.RevisionType) predicate.Revision { 203 v := make([]any, len(vs)) 204 for i := range v { 205 v[i] = uint(vs[i]) 206 } 207 return predicate.Revision(sql.FieldIn(FieldType, v...)) 208 } 209 210 // TypeNotIn applies the NotIn predicate on the "type" field. 211 func TypeNotIn(vs ...migrate.RevisionType) predicate.Revision { 212 v := make([]any, len(vs)) 213 for i := range v { 214 v[i] = uint(vs[i]) 215 } 216 return predicate.Revision(sql.FieldNotIn(FieldType, v...)) 217 } 218 219 // TypeGT applies the GT predicate on the "type" field. 220 func TypeGT(v migrate.RevisionType) predicate.Revision { 221 vc := uint(v) 222 return predicate.Revision(sql.FieldGT(FieldType, vc)) 223 } 224 225 // TypeGTE applies the GTE predicate on the "type" field. 226 func TypeGTE(v migrate.RevisionType) predicate.Revision { 227 vc := uint(v) 228 return predicate.Revision(sql.FieldGTE(FieldType, vc)) 229 } 230 231 // TypeLT applies the LT predicate on the "type" field. 232 func TypeLT(v migrate.RevisionType) predicate.Revision { 233 vc := uint(v) 234 return predicate.Revision(sql.FieldLT(FieldType, vc)) 235 } 236 237 // TypeLTE applies the LTE predicate on the "type" field. 238 func TypeLTE(v migrate.RevisionType) predicate.Revision { 239 vc := uint(v) 240 return predicate.Revision(sql.FieldLTE(FieldType, vc)) 241 } 242 243 // AppliedEQ applies the EQ predicate on the "applied" field. 244 func AppliedEQ(v int) predicate.Revision { 245 return predicate.Revision(sql.FieldEQ(FieldApplied, v)) 246 } 247 248 // AppliedNEQ applies the NEQ predicate on the "applied" field. 249 func AppliedNEQ(v int) predicate.Revision { 250 return predicate.Revision(sql.FieldNEQ(FieldApplied, v)) 251 } 252 253 // AppliedIn applies the In predicate on the "applied" field. 254 func AppliedIn(vs ...int) predicate.Revision { 255 return predicate.Revision(sql.FieldIn(FieldApplied, vs...)) 256 } 257 258 // AppliedNotIn applies the NotIn predicate on the "applied" field. 259 func AppliedNotIn(vs ...int) predicate.Revision { 260 return predicate.Revision(sql.FieldNotIn(FieldApplied, vs...)) 261 } 262 263 // AppliedGT applies the GT predicate on the "applied" field. 264 func AppliedGT(v int) predicate.Revision { 265 return predicate.Revision(sql.FieldGT(FieldApplied, v)) 266 } 267 268 // AppliedGTE applies the GTE predicate on the "applied" field. 269 func AppliedGTE(v int) predicate.Revision { 270 return predicate.Revision(sql.FieldGTE(FieldApplied, v)) 271 } 272 273 // AppliedLT applies the LT predicate on the "applied" field. 274 func AppliedLT(v int) predicate.Revision { 275 return predicate.Revision(sql.FieldLT(FieldApplied, v)) 276 } 277 278 // AppliedLTE applies the LTE predicate on the "applied" field. 279 func AppliedLTE(v int) predicate.Revision { 280 return predicate.Revision(sql.FieldLTE(FieldApplied, v)) 281 } 282 283 // TotalEQ applies the EQ predicate on the "total" field. 284 func TotalEQ(v int) predicate.Revision { 285 return predicate.Revision(sql.FieldEQ(FieldTotal, v)) 286 } 287 288 // TotalNEQ applies the NEQ predicate on the "total" field. 289 func TotalNEQ(v int) predicate.Revision { 290 return predicate.Revision(sql.FieldNEQ(FieldTotal, v)) 291 } 292 293 // TotalIn applies the In predicate on the "total" field. 294 func TotalIn(vs ...int) predicate.Revision { 295 return predicate.Revision(sql.FieldIn(FieldTotal, vs...)) 296 } 297 298 // TotalNotIn applies the NotIn predicate on the "total" field. 299 func TotalNotIn(vs ...int) predicate.Revision { 300 return predicate.Revision(sql.FieldNotIn(FieldTotal, vs...)) 301 } 302 303 // TotalGT applies the GT predicate on the "total" field. 304 func TotalGT(v int) predicate.Revision { 305 return predicate.Revision(sql.FieldGT(FieldTotal, v)) 306 } 307 308 // TotalGTE applies the GTE predicate on the "total" field. 309 func TotalGTE(v int) predicate.Revision { 310 return predicate.Revision(sql.FieldGTE(FieldTotal, v)) 311 } 312 313 // TotalLT applies the LT predicate on the "total" field. 314 func TotalLT(v int) predicate.Revision { 315 return predicate.Revision(sql.FieldLT(FieldTotal, v)) 316 } 317 318 // TotalLTE applies the LTE predicate on the "total" field. 319 func TotalLTE(v int) predicate.Revision { 320 return predicate.Revision(sql.FieldLTE(FieldTotal, v)) 321 } 322 323 // ExecutedAtEQ applies the EQ predicate on the "executed_at" field. 324 func ExecutedAtEQ(v time.Time) predicate.Revision { 325 return predicate.Revision(sql.FieldEQ(FieldExecutedAt, v)) 326 } 327 328 // ExecutedAtNEQ applies the NEQ predicate on the "executed_at" field. 329 func ExecutedAtNEQ(v time.Time) predicate.Revision { 330 return predicate.Revision(sql.FieldNEQ(FieldExecutedAt, v)) 331 } 332 333 // ExecutedAtIn applies the In predicate on the "executed_at" field. 334 func ExecutedAtIn(vs ...time.Time) predicate.Revision { 335 return predicate.Revision(sql.FieldIn(FieldExecutedAt, vs...)) 336 } 337 338 // ExecutedAtNotIn applies the NotIn predicate on the "executed_at" field. 339 func ExecutedAtNotIn(vs ...time.Time) predicate.Revision { 340 return predicate.Revision(sql.FieldNotIn(FieldExecutedAt, vs...)) 341 } 342 343 // ExecutedAtGT applies the GT predicate on the "executed_at" field. 344 func ExecutedAtGT(v time.Time) predicate.Revision { 345 return predicate.Revision(sql.FieldGT(FieldExecutedAt, v)) 346 } 347 348 // ExecutedAtGTE applies the GTE predicate on the "executed_at" field. 349 func ExecutedAtGTE(v time.Time) predicate.Revision { 350 return predicate.Revision(sql.FieldGTE(FieldExecutedAt, v)) 351 } 352 353 // ExecutedAtLT applies the LT predicate on the "executed_at" field. 354 func ExecutedAtLT(v time.Time) predicate.Revision { 355 return predicate.Revision(sql.FieldLT(FieldExecutedAt, v)) 356 } 357 358 // ExecutedAtLTE applies the LTE predicate on the "executed_at" field. 359 func ExecutedAtLTE(v time.Time) predicate.Revision { 360 return predicate.Revision(sql.FieldLTE(FieldExecutedAt, v)) 361 } 362 363 // ExecutionTimeEQ applies the EQ predicate on the "execution_time" field. 364 func ExecutionTimeEQ(v time.Duration) predicate.Revision { 365 vc := int64(v) 366 return predicate.Revision(sql.FieldEQ(FieldExecutionTime, vc)) 367 } 368 369 // ExecutionTimeNEQ applies the NEQ predicate on the "execution_time" field. 370 func ExecutionTimeNEQ(v time.Duration) predicate.Revision { 371 vc := int64(v) 372 return predicate.Revision(sql.FieldNEQ(FieldExecutionTime, vc)) 373 } 374 375 // ExecutionTimeIn applies the In predicate on the "execution_time" field. 376 func ExecutionTimeIn(vs ...time.Duration) predicate.Revision { 377 v := make([]any, len(vs)) 378 for i := range v { 379 v[i] = int64(vs[i]) 380 } 381 return predicate.Revision(sql.FieldIn(FieldExecutionTime, v...)) 382 } 383 384 // ExecutionTimeNotIn applies the NotIn predicate on the "execution_time" field. 385 func ExecutionTimeNotIn(vs ...time.Duration) predicate.Revision { 386 v := make([]any, len(vs)) 387 for i := range v { 388 v[i] = int64(vs[i]) 389 } 390 return predicate.Revision(sql.FieldNotIn(FieldExecutionTime, v...)) 391 } 392 393 // ExecutionTimeGT applies the GT predicate on the "execution_time" field. 394 func ExecutionTimeGT(v time.Duration) predicate.Revision { 395 vc := int64(v) 396 return predicate.Revision(sql.FieldGT(FieldExecutionTime, vc)) 397 } 398 399 // ExecutionTimeGTE applies the GTE predicate on the "execution_time" field. 400 func ExecutionTimeGTE(v time.Duration) predicate.Revision { 401 vc := int64(v) 402 return predicate.Revision(sql.FieldGTE(FieldExecutionTime, vc)) 403 } 404 405 // ExecutionTimeLT applies the LT predicate on the "execution_time" field. 406 func ExecutionTimeLT(v time.Duration) predicate.Revision { 407 vc := int64(v) 408 return predicate.Revision(sql.FieldLT(FieldExecutionTime, vc)) 409 } 410 411 // ExecutionTimeLTE applies the LTE predicate on the "execution_time" field. 412 func ExecutionTimeLTE(v time.Duration) predicate.Revision { 413 vc := int64(v) 414 return predicate.Revision(sql.FieldLTE(FieldExecutionTime, vc)) 415 } 416 417 // ErrorEQ applies the EQ predicate on the "error" field. 418 func ErrorEQ(v string) predicate.Revision { 419 return predicate.Revision(sql.FieldEQ(FieldError, v)) 420 } 421 422 // ErrorNEQ applies the NEQ predicate on the "error" field. 423 func ErrorNEQ(v string) predicate.Revision { 424 return predicate.Revision(sql.FieldNEQ(FieldError, v)) 425 } 426 427 // ErrorIn applies the In predicate on the "error" field. 428 func ErrorIn(vs ...string) predicate.Revision { 429 return predicate.Revision(sql.FieldIn(FieldError, vs...)) 430 } 431 432 // ErrorNotIn applies the NotIn predicate on the "error" field. 433 func ErrorNotIn(vs ...string) predicate.Revision { 434 return predicate.Revision(sql.FieldNotIn(FieldError, vs...)) 435 } 436 437 // ErrorGT applies the GT predicate on the "error" field. 438 func ErrorGT(v string) predicate.Revision { 439 return predicate.Revision(sql.FieldGT(FieldError, v)) 440 } 441 442 // ErrorGTE applies the GTE predicate on the "error" field. 443 func ErrorGTE(v string) predicate.Revision { 444 return predicate.Revision(sql.FieldGTE(FieldError, v)) 445 } 446 447 // ErrorLT applies the LT predicate on the "error" field. 448 func ErrorLT(v string) predicate.Revision { 449 return predicate.Revision(sql.FieldLT(FieldError, v)) 450 } 451 452 // ErrorLTE applies the LTE predicate on the "error" field. 453 func ErrorLTE(v string) predicate.Revision { 454 return predicate.Revision(sql.FieldLTE(FieldError, v)) 455 } 456 457 // ErrorContains applies the Contains predicate on the "error" field. 458 func ErrorContains(v string) predicate.Revision { 459 return predicate.Revision(sql.FieldContains(FieldError, v)) 460 } 461 462 // ErrorHasPrefix applies the HasPrefix predicate on the "error" field. 463 func ErrorHasPrefix(v string) predicate.Revision { 464 return predicate.Revision(sql.FieldHasPrefix(FieldError, v)) 465 } 466 467 // ErrorHasSuffix applies the HasSuffix predicate on the "error" field. 468 func ErrorHasSuffix(v string) predicate.Revision { 469 return predicate.Revision(sql.FieldHasSuffix(FieldError, v)) 470 } 471 472 // ErrorIsNil applies the IsNil predicate on the "error" field. 473 func ErrorIsNil() predicate.Revision { 474 return predicate.Revision(sql.FieldIsNull(FieldError)) 475 } 476 477 // ErrorNotNil applies the NotNil predicate on the "error" field. 478 func ErrorNotNil() predicate.Revision { 479 return predicate.Revision(sql.FieldNotNull(FieldError)) 480 } 481 482 // ErrorEqualFold applies the EqualFold predicate on the "error" field. 483 func ErrorEqualFold(v string) predicate.Revision { 484 return predicate.Revision(sql.FieldEqualFold(FieldError, v)) 485 } 486 487 // ErrorContainsFold applies the ContainsFold predicate on the "error" field. 488 func ErrorContainsFold(v string) predicate.Revision { 489 return predicate.Revision(sql.FieldContainsFold(FieldError, v)) 490 } 491 492 // ErrorStmtEQ applies the EQ predicate on the "error_stmt" field. 493 func ErrorStmtEQ(v string) predicate.Revision { 494 return predicate.Revision(sql.FieldEQ(FieldErrorStmt, v)) 495 } 496 497 // ErrorStmtNEQ applies the NEQ predicate on the "error_stmt" field. 498 func ErrorStmtNEQ(v string) predicate.Revision { 499 return predicate.Revision(sql.FieldNEQ(FieldErrorStmt, v)) 500 } 501 502 // ErrorStmtIn applies the In predicate on the "error_stmt" field. 503 func ErrorStmtIn(vs ...string) predicate.Revision { 504 return predicate.Revision(sql.FieldIn(FieldErrorStmt, vs...)) 505 } 506 507 // ErrorStmtNotIn applies the NotIn predicate on the "error_stmt" field. 508 func ErrorStmtNotIn(vs ...string) predicate.Revision { 509 return predicate.Revision(sql.FieldNotIn(FieldErrorStmt, vs...)) 510 } 511 512 // ErrorStmtGT applies the GT predicate on the "error_stmt" field. 513 func ErrorStmtGT(v string) predicate.Revision { 514 return predicate.Revision(sql.FieldGT(FieldErrorStmt, v)) 515 } 516 517 // ErrorStmtGTE applies the GTE predicate on the "error_stmt" field. 518 func ErrorStmtGTE(v string) predicate.Revision { 519 return predicate.Revision(sql.FieldGTE(FieldErrorStmt, v)) 520 } 521 522 // ErrorStmtLT applies the LT predicate on the "error_stmt" field. 523 func ErrorStmtLT(v string) predicate.Revision { 524 return predicate.Revision(sql.FieldLT(FieldErrorStmt, v)) 525 } 526 527 // ErrorStmtLTE applies the LTE predicate on the "error_stmt" field. 528 func ErrorStmtLTE(v string) predicate.Revision { 529 return predicate.Revision(sql.FieldLTE(FieldErrorStmt, v)) 530 } 531 532 // ErrorStmtContains applies the Contains predicate on the "error_stmt" field. 533 func ErrorStmtContains(v string) predicate.Revision { 534 return predicate.Revision(sql.FieldContains(FieldErrorStmt, v)) 535 } 536 537 // ErrorStmtHasPrefix applies the HasPrefix predicate on the "error_stmt" field. 538 func ErrorStmtHasPrefix(v string) predicate.Revision { 539 return predicate.Revision(sql.FieldHasPrefix(FieldErrorStmt, v)) 540 } 541 542 // ErrorStmtHasSuffix applies the HasSuffix predicate on the "error_stmt" field. 543 func ErrorStmtHasSuffix(v string) predicate.Revision { 544 return predicate.Revision(sql.FieldHasSuffix(FieldErrorStmt, v)) 545 } 546 547 // ErrorStmtIsNil applies the IsNil predicate on the "error_stmt" field. 548 func ErrorStmtIsNil() predicate.Revision { 549 return predicate.Revision(sql.FieldIsNull(FieldErrorStmt)) 550 } 551 552 // ErrorStmtNotNil applies the NotNil predicate on the "error_stmt" field. 553 func ErrorStmtNotNil() predicate.Revision { 554 return predicate.Revision(sql.FieldNotNull(FieldErrorStmt)) 555 } 556 557 // ErrorStmtEqualFold applies the EqualFold predicate on the "error_stmt" field. 558 func ErrorStmtEqualFold(v string) predicate.Revision { 559 return predicate.Revision(sql.FieldEqualFold(FieldErrorStmt, v)) 560 } 561 562 // ErrorStmtContainsFold applies the ContainsFold predicate on the "error_stmt" field. 563 func ErrorStmtContainsFold(v string) predicate.Revision { 564 return predicate.Revision(sql.FieldContainsFold(FieldErrorStmt, v)) 565 } 566 567 // HashEQ applies the EQ predicate on the "hash" field. 568 func HashEQ(v string) predicate.Revision { 569 return predicate.Revision(sql.FieldEQ(FieldHash, v)) 570 } 571 572 // HashNEQ applies the NEQ predicate on the "hash" field. 573 func HashNEQ(v string) predicate.Revision { 574 return predicate.Revision(sql.FieldNEQ(FieldHash, v)) 575 } 576 577 // HashIn applies the In predicate on the "hash" field. 578 func HashIn(vs ...string) predicate.Revision { 579 return predicate.Revision(sql.FieldIn(FieldHash, vs...)) 580 } 581 582 // HashNotIn applies the NotIn predicate on the "hash" field. 583 func HashNotIn(vs ...string) predicate.Revision { 584 return predicate.Revision(sql.FieldNotIn(FieldHash, vs...)) 585 } 586 587 // HashGT applies the GT predicate on the "hash" field. 588 func HashGT(v string) predicate.Revision { 589 return predicate.Revision(sql.FieldGT(FieldHash, v)) 590 } 591 592 // HashGTE applies the GTE predicate on the "hash" field. 593 func HashGTE(v string) predicate.Revision { 594 return predicate.Revision(sql.FieldGTE(FieldHash, v)) 595 } 596 597 // HashLT applies the LT predicate on the "hash" field. 598 func HashLT(v string) predicate.Revision { 599 return predicate.Revision(sql.FieldLT(FieldHash, v)) 600 } 601 602 // HashLTE applies the LTE predicate on the "hash" field. 603 func HashLTE(v string) predicate.Revision { 604 return predicate.Revision(sql.FieldLTE(FieldHash, v)) 605 } 606 607 // HashContains applies the Contains predicate on the "hash" field. 608 func HashContains(v string) predicate.Revision { 609 return predicate.Revision(sql.FieldContains(FieldHash, v)) 610 } 611 612 // HashHasPrefix applies the HasPrefix predicate on the "hash" field. 613 func HashHasPrefix(v string) predicate.Revision { 614 return predicate.Revision(sql.FieldHasPrefix(FieldHash, v)) 615 } 616 617 // HashHasSuffix applies the HasSuffix predicate on the "hash" field. 618 func HashHasSuffix(v string) predicate.Revision { 619 return predicate.Revision(sql.FieldHasSuffix(FieldHash, v)) 620 } 621 622 // HashEqualFold applies the EqualFold predicate on the "hash" field. 623 func HashEqualFold(v string) predicate.Revision { 624 return predicate.Revision(sql.FieldEqualFold(FieldHash, v)) 625 } 626 627 // HashContainsFold applies the ContainsFold predicate on the "hash" field. 628 func HashContainsFold(v string) predicate.Revision { 629 return predicate.Revision(sql.FieldContainsFold(FieldHash, v)) 630 } 631 632 // PartialHashesIsNil applies the IsNil predicate on the "partial_hashes" field. 633 func PartialHashesIsNil() predicate.Revision { 634 return predicate.Revision(sql.FieldIsNull(FieldPartialHashes)) 635 } 636 637 // PartialHashesNotNil applies the NotNil predicate on the "partial_hashes" field. 638 func PartialHashesNotNil() predicate.Revision { 639 return predicate.Revision(sql.FieldNotNull(FieldPartialHashes)) 640 } 641 642 // OperatorVersionEQ applies the EQ predicate on the "operator_version" field. 643 func OperatorVersionEQ(v string) predicate.Revision { 644 return predicate.Revision(sql.FieldEQ(FieldOperatorVersion, v)) 645 } 646 647 // OperatorVersionNEQ applies the NEQ predicate on the "operator_version" field. 648 func OperatorVersionNEQ(v string) predicate.Revision { 649 return predicate.Revision(sql.FieldNEQ(FieldOperatorVersion, v)) 650 } 651 652 // OperatorVersionIn applies the In predicate on the "operator_version" field. 653 func OperatorVersionIn(vs ...string) predicate.Revision { 654 return predicate.Revision(sql.FieldIn(FieldOperatorVersion, vs...)) 655 } 656 657 // OperatorVersionNotIn applies the NotIn predicate on the "operator_version" field. 658 func OperatorVersionNotIn(vs ...string) predicate.Revision { 659 return predicate.Revision(sql.FieldNotIn(FieldOperatorVersion, vs...)) 660 } 661 662 // OperatorVersionGT applies the GT predicate on the "operator_version" field. 663 func OperatorVersionGT(v string) predicate.Revision { 664 return predicate.Revision(sql.FieldGT(FieldOperatorVersion, v)) 665 } 666 667 // OperatorVersionGTE applies the GTE predicate on the "operator_version" field. 668 func OperatorVersionGTE(v string) predicate.Revision { 669 return predicate.Revision(sql.FieldGTE(FieldOperatorVersion, v)) 670 } 671 672 // OperatorVersionLT applies the LT predicate on the "operator_version" field. 673 func OperatorVersionLT(v string) predicate.Revision { 674 return predicate.Revision(sql.FieldLT(FieldOperatorVersion, v)) 675 } 676 677 // OperatorVersionLTE applies the LTE predicate on the "operator_version" field. 678 func OperatorVersionLTE(v string) predicate.Revision { 679 return predicate.Revision(sql.FieldLTE(FieldOperatorVersion, v)) 680 } 681 682 // OperatorVersionContains applies the Contains predicate on the "operator_version" field. 683 func OperatorVersionContains(v string) predicate.Revision { 684 return predicate.Revision(sql.FieldContains(FieldOperatorVersion, v)) 685 } 686 687 // OperatorVersionHasPrefix applies the HasPrefix predicate on the "operator_version" field. 688 func OperatorVersionHasPrefix(v string) predicate.Revision { 689 return predicate.Revision(sql.FieldHasPrefix(FieldOperatorVersion, v)) 690 } 691 692 // OperatorVersionHasSuffix applies the HasSuffix predicate on the "operator_version" field. 693 func OperatorVersionHasSuffix(v string) predicate.Revision { 694 return predicate.Revision(sql.FieldHasSuffix(FieldOperatorVersion, v)) 695 } 696 697 // OperatorVersionEqualFold applies the EqualFold predicate on the "operator_version" field. 698 func OperatorVersionEqualFold(v string) predicate.Revision { 699 return predicate.Revision(sql.FieldEqualFold(FieldOperatorVersion, v)) 700 } 701 702 // OperatorVersionContainsFold applies the ContainsFold predicate on the "operator_version" field. 703 func OperatorVersionContainsFold(v string) predicate.Revision { 704 return predicate.Revision(sql.FieldContainsFold(FieldOperatorVersion, v)) 705 } 706 707 // And groups predicates with the AND operator between them. 708 func And(predicates ...predicate.Revision) predicate.Revision { 709 return predicate.Revision(func(s *sql.Selector) { 710 s1 := s.Clone().SetP(nil) 711 for _, p := range predicates { 712 p(s1) 713 } 714 s.Where(s1.P()) 715 }) 716 } 717 718 // Or groups predicates with the OR operator between them. 719 func Or(predicates ...predicate.Revision) predicate.Revision { 720 return predicate.Revision(func(s *sql.Selector) { 721 s1 := s.Clone().SetP(nil) 722 for i, p := range predicates { 723 if i > 0 { 724 s1.Or() 725 } 726 p(s1) 727 } 728 s.Where(s1.P()) 729 }) 730 } 731 732 // Not applies the not operator on the given predicate. 733 func Not(p predicate.Revision) predicate.Revision { 734 return predicate.Revision(func(s *sql.Selector) { 735 p(s.Not()) 736 }) 737 }