juju/juju-vnfmadapter/Juju-vnfmadapterService/service/src/main/java/org/onap/vfc/nfvo/vnfm/gvnfm/jujuvnfmadapter/service/entity/JujuVnfmInfoExample.java

   1 /*
   2  * Copyright 2016 Huawei Technologies Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.vfc.nfvo.vnfm.gvnfm.jujuvnfmadapter.service.entity;
  18
  19 import java.util.ArrayList;
  20 import java.util.Date;
  21 import java.util.List;
  22
  23 /**
  24  * JUJU VNFM Information example
  25  * .</br>
  26  *
  27  * @author
  28  * @version     NFVO 0.5  Sep 14, 2016
  29  */
  30 public class JujuVnfmInfoExample {
  31     protected String orderByClause;
  32
  33     protected boolean distinct;
  34
  35     protected List<Criteria> oredCriteria;
  36
  37     protected int limitStart = -1;
  38
  39     protected int limitEnd = -1;
  40
  41     public static final String VNFM_ID = "vnfmId";
  42
  43     public static final String VNF_ID = "vnfId";
  44
  45     public static final String APP_NAME = "appName";
  46
  47     public static final String JOB_ID = "jobId";
  48
  49     public static final String STATUS = "status";
  50
  51     public static final String CREATE_TIME = "createTime";
  52
  53     public static final String MODIFY_TIME  = "modifyTime";
  54
  55     public static final String DELETE_TIME   = "deleteTime";
  56
  57     /**
  58      * Constructor<br/>
  59      * <p>
  60      * </p>
  61      */
  62     public JujuVnfmInfoExample() {
  63         oredCriteria = new ArrayList<>();
  64     }
  65
  66     public void setOrderByClause(String orderByClause) {
  67         this.orderByClause = orderByClause;
  68     }
  69
  70     public String getOrderByClause() {
  71         return orderByClause;
  72     }
  73
  74     public void setDistinct(boolean distinct) {
  75         this.distinct = distinct;
  76     }
  77
  78     public boolean isDistinct() {
  79         return distinct;
  80     }
  81
  82     public List<Criteria> getOredCriteria() {
  83         return oredCriteria;
  84     }
  85
  86     /**
  87      * <br>
  88      *
  89      * @param criteria
  90      */
  91     public void or(Criteria criteria) {
  92         oredCriteria.add(criteria);
  93     }
  94
  95     /**
  96      * <br>
  97      *
  98      * @return
  99      */
 100     public Criteria or() {
 101         Criteria criteria = createCriteriaInternal();
 102         oredCriteria.add(criteria);
 103         return criteria;
 104     }
 105
 106     /**
 107      * <br>
 108      *
 109      * @return
 110      */
 111     public Criteria createCriteria() {
 112         Criteria criteria = createCriteriaInternal();
 113         if (oredCriteria.isEmpty()) {
 114             oredCriteria.add(criteria);
 115         }
 116         return criteria;
 117     }
 118
 119     protected Criteria createCriteriaInternal() {
 120         return new Criteria();
 121     }
 122
 123     /**
 124      * <br>
 125      *
 126      */
 127     public void clear() {
 128         oredCriteria.clear();
 129         orderByClause = null;
 130         distinct = false;
 131     }
 132
 133     public void setLimitStart(int limitStart) {
 134         this.limitStart=limitStart;
 135     }
 136
 137     public int getLimitStart() {
 138         return limitStart;
 139     }
 140
 141     public void setLimitEnd(int limitEnd) {
 142         this.limitEnd=limitEnd;
 143     }
 144
 145     public int getLimitEnd() {
 146         return limitEnd;
 147     }
 148
 149     protected static class GeneratedCriteria {
 150         protected List<Criterion> criteria;
 151
 152         protected GeneratedCriteria() {
 153             super();
 154             criteria = new ArrayList<>();
 155         }
 156
 157         public boolean isValid() {
 158             return !criteria.isEmpty();
 159         }
 160
 161         public List<Criterion> getAllCriteria() {
 162             return criteria;
 163         }
 164
 165         public List<Criterion> getCriteria() {
 166             return criteria;
 167         }
 168
 169         protected void addCriterion(String condition) {
 170             if (condition == null) {
 171                 throw new RuntimeException("Value for condition cannot be null"); //NOSONAR
 172             }
 173             criteria.add(new Criterion(condition));
 174         }
 175
 176         protected void addCriterion(String condition, Object value, String property) {
 177             if (value == null) {
 178                 throw new RuntimeException("Value for " + property + " cannot be null"); //NOSONARr
 179             }
 180             criteria.add(new Criterion(condition, value));
 181         }
 182
 183         protected void addCriterion(String condition, Object value1, Object value2, String property) {
 184             if (value1 == null || value2 == null) {
 185                 throw new RuntimeException("Between values for " + property + " cannot be null"); //NOSONAR
 186             }
 187             criteria.add(new Criterion(condition, value1, value2));
 188         }
 189
 190         /**
 191          * <br>
 192          *
 193          * @return
 194          */
 195         public Criteria andIdIsNull() {
 196             addCriterion("ID is null");
 197             return (Criteria) this;
 198         }
 199
 200         /**
 201          * <br>
 202          *
 203          * @return
 204          */
 205         public Criteria andIdIsNotNull() {
 206             addCriterion("ID is not null");
 207             return (Criteria) this;
 208         }
 209
 210         /**
 211          * <br>
 212          *
 213          * @param value
 214          * @return
 215          */
 216         public Criteria andIdEqualTo(String value) {
 217             addCriterion("ID =", value, "id");
 218             return (Criteria) this;
 219         }
 220
 221         /**
 222          * <br>
 223          *
 224          * @param value
 225          * @return
 226          */
 227         public Criteria andIdNotEqualTo(String value) {
 228             addCriterion("ID <>", value, "id");
 229             return (Criteria) this;
 230         }
 231
 232         /**
 233          * <br>
 234          *
 235          * @param value
 236          * @return
 237          */
 238         public Criteria andIdGreaterThan(String value) {
 239             addCriterion("ID >", value, "id");
 240             return (Criteria) this;
 241         }
 242
 243         /**
 244          * <br>
 245          *
 246          * @param value
 247          * @return
 248          */
 249         public Criteria andIdGreaterThanOrEqualTo(String value) {
 250             addCriterion("ID >=", value, "id");
 251             return (Criteria) this;
 252         }
 253
 254         /**
 255          * <br>
 256          *
 257          * @param value
 258          * @return
 259          */
 260         public Criteria andIdLessThan(String value) {
 261             addCriterion("ID <", value, "id");
 262             return (Criteria) this;
 263         }
 264
 265         /**
 266          * <br>
 267          *
 268          * @param value
 269          * @return
 270          */
 271         public Criteria andIdLessThanOrEqualTo(String value) {
 272             addCriterion("ID <=", value, "id");
 273             return (Criteria) this;
 274         }
 275
 276         /**
 277          * <br>
 278          *
 279          * @param value
 280          * @return
 281          */
 282         public Criteria andIdLike(String value) {
 283             addCriterion("ID like", value, "id");
 284             return (Criteria) this;
 285         }
 286
 287         /**
 288          * <br>
 289          *
 290          * @param value
 291          * @return
 292          */
 293         public Criteria andIdNotLike(String value) {
 294             addCriterion("ID not like", value, "id");
 295             return (Criteria) this;
 296         }
 297
 298         /**
 299          * <br>
 300          *
 301          * @param values
 302          * @return
 303          */
 304         public Criteria andIdIn(List<String> values) {
 305             addCriterion("ID in", values, "id");
 306             return (Criteria) this;
 307         }
 308
 309         /**
 310          * <br>
 311          *
 312          * @param values
 313          * @return
 314          */
 315         public Criteria andIdNotIn(List<String> values) {
 316             addCriterion("ID not in", values, "id");
 317             return (Criteria) this;
 318         }
 319
 320         /**
 321          * <br>
 322          *
 323          * @param value1
 324          * @param value2
 325          * @return
 326          */
 327         public Criteria andIdBetween(String value1, String value2) {
 328             addCriterion("ID between", value1, value2, "id");
 329             return (Criteria) this;
 330         }
 331
 332         /**
 333          * <br>
 334          *
 335          * @param value1
 336          * @param value2
 337          * @return
 338          */
 339         public Criteria andIdNotBetween(String value1, String value2) {
 340             addCriterion("ID not between", value1, value2, "id");
 341             return (Criteria) this;
 342         }
 343
 344         /**
 345          * <br>
 346          *
 347          * @return
 348          */
 349         public Criteria andVnfmIdIsNull() {
 350             addCriterion("VNFM_ID is null");
 351             return (Criteria) this;
 352         }
 353
 354         /**
 355          * <br>
 356          *
 357          * @return
 358          */
 359         public Criteria andVnfmIdIsNotNull() {
 360             addCriterion("VNFM_ID is not null");
 361             return (Criteria) this;
 362         }
 363
 364         /**
 365          * <br>
 366          *
 367          * @param value
 368          * @return
 369          */
 370         public Criteria andVnfmIdEqualTo(String value) {
 371             addCriterion("VNFM_ID =", value, VNFM_ID);
 372             return (Criteria) this;
 373         }
 374
 375         /**
 376          * <br>
 377          *
 378          * @param value
 379          * @return
 380          */
 381         public Criteria andVnfmIdNotEqualTo(String value) {
 382             addCriterion("VNFM_ID <>", value, VNFM_ID);
 383             return (Criteria) this;
 384         }
 385
 386         /**
 387          * <br>
 388          *
 389          * @param value
 390          * @return
 391          */
 392         public Criteria andVnfmIdGreaterThan(String value) {
 393             addCriterion("VNFM_ID >", value, VNFM_ID);
 394             return (Criteria) this;
 395         }
 396
 397         /**
 398          * <br>
 399          *
 400          * @param value
 401          * @return
 402          */
 403         public Criteria andVnfmIdGreaterThanOrEqualTo(String value) {
 404             addCriterion("VNFM_ID >=", value, VNFM_ID);
 405             return (Criteria) this;
 406         }
 407
 408         /**
 409          * <br>
 410          *
 411          * @param value
 412          * @return
 413          */
 414         public Criteria andVnfmIdLessThan(String value) {
 415             addCriterion("VNFM_ID <", value, VNFM_ID);
 416             return (Criteria) this;
 417         }
 418
 419         /**
 420          * <br>
 421          *
 422          * @param value
 423          * @return
 424          */
 425         public Criteria andVnfmIdLessThanOrEqualTo(String value) {
 426             addCriterion("VNFM_ID <=", value, VNFM_ID);
 427             return (Criteria) this;
 428         }
 429
 430         /**
 431          * <br>
 432          *
 433          * @param value
 434          * @return
 435          */
 436         public Criteria andVnfmIdLike(String value) {
 437             addCriterion("VNFM_ID like", value, VNFM_ID);
 438             return (Criteria) this;
 439         }
 440
 441         /**
 442          * <br>
 443          *
 444          * @param value
 445          * @return
 446          */
 447         public Criteria andVnfmIdNotLike(String value) {
 448             addCriterion("VNFM_ID not like", value, VNFM_ID);
 449             return (Criteria) this;
 450         }
 451
 452         /**
 453          * <br>
 454          *
 455          * @param values
 456          * @return
 457          */
 458         public Criteria andVnfmIdIn(List<String> values) {
 459             addCriterion("VNFM_ID in", values, VNFM_ID);
 460             return (Criteria) this;
 461         }
 462
 463         /**
 464          * <br>
 465          *
 466          * @param values
 467          * @return
 468          */
 469         public Criteria andVnfmIdNotIn(List<String> values) {
 470             addCriterion("VNFM_ID not in", values, VNFM_ID);
 471             return (Criteria) this;
 472         }
 473
 474         /**
 475          * <br>
 476          *
 477          * @param value1
 478          * @param value2
 479          * @return
 480          */
 481         public Criteria andVnfmIdBetween(String value1, String value2) {
 482             addCriterion("VNFM_ID between", value1, value2, VNFM_ID);
 483             return (Criteria) this;
 484         }
 485
 486         /**
 487          * <br>
 488          *
 489          * @param value1
 490          * @param value2
 491          * @return
 492          */
 493         public Criteria andVnfmIdNotBetween(String value1, String value2) {
 494             addCriterion("VNFM_ID not between", value1, value2, VNFM_ID);
 495             return (Criteria) this;
 496         }
 497
 498         /**
 499          * <br>
 500          *
 501          * @return
 502          */
 503         public Criteria andVnfIdIsNull() {
 504             addCriterion("VNF_ID is null");
 505             return (Criteria) this;
 506         }
 507
 508         /**
 509          * <br>
 510          *
 511          * @return
 512          */
 513         public Criteria andVnfIdIsNotNull() {
 514             addCriterion("VNF_ID is not null");
 515             return (Criteria) this;
 516         }
 517
 518         /**
 519          * <br>
 520          *
 521          * @param value
 522          * @return
 523          */
 524         public Criteria andVnfIdEqualTo(String value) {
 525             addCriterion("VNF_ID =", value, VNF_ID);
 526             return (Criteria) this;
 527         }
 528
 529         /**
 530          * <br>
 531          *
 532          * @param value
 533          * @return
 534          */
 535         public Criteria andVnfIdNotEqualTo(String value) {
 536             addCriterion("VNF_ID <>", value, VNF_ID);
 537             return (Criteria) this;
 538         }
 539
 540         /**
 541          * <br>
 542          *
 543          * @param value
 544          * @return
 545          */
 546         public Criteria andVnfIdGreaterThan(String value) {
 547             addCriterion("VNF_ID >", value, VNF_ID);
 548             return (Criteria) this;
 549         }
 550
 551         /**
 552          * <br>
 553          *
 554          * @param value
 555          * @return
 556          */
 557         public Criteria andVnfIdGreaterThanOrEqualTo(String value) {
 558             addCriterion("VNF_ID >=", value, VNF_ID);
 559             return (Criteria) this;
 560         }
 561
 562         /**
 563          * <br>
 564          *
 565          * @param value
 566          * @return
 567          */
 568         public Criteria andVnfIdLessThan(String value) {
 569             addCriterion("VNF_ID <", value, VNF_ID);
 570             return (Criteria) this;
 571         }
 572
 573         /**
 574          * <br>
 575          *
 576          * @param value
 577          * @return
 578          */
 579         public Criteria andVnfIdLessThanOrEqualTo(String value) {
 580             addCriterion("VNF_ID <=", value, VNF_ID);
 581             return (Criteria) this;
 582         }
 583
 584         /**
 585          * <br>
 586          *
 587          * @param value
 588          * @return
 589          */
 590         public Criteria andVnfIdLike(String value) {
 591             addCriterion("VNF_ID like", value, VNF_ID);
 592             return (Criteria) this;
 593         }
 594
 595         /**
 596          * <br>
 597          *
 598          * @param value
 599          * @return
 600          */
 601         public Criteria andVnfIdNotLike(String value) {
 602             addCriterion("VNF_ID not like", value, VNF_ID);
 603             return (Criteria) this;
 604         }
 605
 606         /**
 607          * <br>
 608          *
 609          * @param values
 610          * @return
 611          */
 612         public Criteria andVnfIdIn(List<String> values) {
 613             addCriterion("VNF_ID in", values, VNF_ID);
 614             return (Criteria) this;
 615         }
 616
 617         /**
 618          * <br>
 619          *
 620          * @param values
 621          * @return
 622          */
 623         public Criteria andVnfIdNotIn(List<String> values) {
 624             addCriterion("VNF_ID not in", values, VNF_ID);
 625             return (Criteria) this;
 626         }
 627
 628         /**
 629          * <br>
 630          *
 631          * @param value1
 632          * @param value2
 633          * @return
 634          */
 635         public Criteria andVnfIdBetween(String value1, String value2) {
 636             addCriterion("VNF_ID between", value1, value2, VNF_ID);
 637             return (Criteria) this;
 638         }
 639
 640         /**
 641          * <br>
 642          *
 643          * @param value1
 644          * @param value2
 645          * @return
 646          */
 647         public Criteria andVnfIdNotBetween(String value1, String value2) {
 648             addCriterion("VNF_ID not between", value1, value2, VNF_ID);
 649             return (Criteria) this;
 650         }
 651
 652         /**
 653          * <br>
 654          *
 655          * @return
 656          */
 657         public Criteria andAppNameIsNull() {
 658             addCriterion("APP_NAME is null");
 659             return (Criteria) this;
 660         }
 661
 662         /**
 663          * <br>
 664          *
 665          * @return
 666          */
 667         public Criteria andAppNameIsNotNull() {
 668             addCriterion("APP_NAME is not null");
 669             return (Criteria) this;
 670         }
 671
 672         /**
 673          * <br>
 674          *
 675          * @param value
 676          * @return
 677          */
 678         public Criteria andAppNameEqualTo(String value) {
 679             addCriterion("APP_NAME =", value, APP_NAME);
 680             return (Criteria) this;
 681         }
 682
 683         /**
 684          * <br>
 685          *
 686          * @param value
 687          * @return
 688          */
 689         public Criteria andAppNameNotEqualTo(String value) {
 690             addCriterion("APP_NAME <>", value, APP_NAME);
 691             return (Criteria) this;
 692         }
 693
 694         /**
 695          * <br>
 696          *
 697          * @param value
 698          * @return
 699          */
 700         public Criteria andAppNameGreaterThan(String value) {
 701             addCriterion("APP_NAME >", value, APP_NAME);
 702             return (Criteria) this;
 703         }
 704
 705         /**
 706          * <br>
 707          *
 708          * @param value
 709          * @return
 710          */
 711         public Criteria andAppNameGreaterThanOrEqualTo(String value) {
 712             addCriterion("APP_NAME >=", value, APP_NAME);
 713             return (Criteria) this;
 714         }
 715
 716         /**
 717          * <br>
 718          *
 719          * @param value
 720          * @return
 721          */
 722         public Criteria andAppNameLessThan(String value) {
 723             addCriterion("APP_NAME <", value, APP_NAME);
 724             return (Criteria) this;
 725         }
 726
 727         /**
 728          * <br>
 729          *
 730          * @param value
 731          * @return
 732          */
 733         public Criteria andAppNameLessThanOrEqualTo(String value) {
 734             addCriterion("APP_NAME <=", value, APP_NAME);
 735             return (Criteria) this;
 736         }
 737
 738         /**
 739          * <br>
 740          *
 741          * @param value
 742          * @return
 743          */
 744         public Criteria andAppNameLike(String value) {
 745             addCriterion("APP_NAME like", value, APP_NAME);
 746             return (Criteria) this;
 747         }
 748
 749         /**
 750          * <br>
 751          *
 752          * @param value
 753          * @return
 754          */
 755         public Criteria andAppNameNotLike(String value) {
 756             addCriterion("APP_NAME not like", value, APP_NAME);
 757             return (Criteria) this;
 758         }
 759
 760         /**
 761          * <br>
 762          *
 763          * @param values
 764          * @return
 765          */
 766         public Criteria andAppNameIn(List<String> values) {
 767             addCriterion("APP_NAME in", values, APP_NAME);
 768             return (Criteria) this;
 769         }
 770
 771         /**
 772          * <br>
 773          *
 774          * @param values
 775          * @return
 776          */
 777         public Criteria andAppNameNotIn(List<String> values) {
 778             addCriterion("APP_NAME not in", values, APP_NAME);
 779             return (Criteria) this;
 780         }
 781
 782         /**
 783          * <br>
 784          *
 785          * @param value1
 786          * @param value2
 787          * @return
 788          */
 789         public Criteria andAppNameBetween(String value1, String value2) {
 790             addCriterion("APP_NAME between", value1, value2, APP_NAME);
 791             return (Criteria) this;
 792         }
 793
 794         /**
 795          * <br>
 796          *
 797          * @param value1
 798          * @param value2
 799          * @return
 800          */
 801         public Criteria andAppNameNotBetween(String value1, String value2) {
 802             addCriterion("APP_NAME not between", value1, value2, APP_NAME);
 803             return (Criteria) this;
 804         }
 805
 806         /**
 807          * <br>
 808          *
 809          * @return
 810          */
 811         public Criteria andJobIdIsNull() {
 812             addCriterion("JOB_ID is null");
 813             return (Criteria) this;
 814         }
 815
 816         /**
 817          * <br>
 818          *
 819          * @return
 820          */
 821         public Criteria andJobIdIsNotNull() {
 822             addCriterion("JOB_ID is not null");
 823             return (Criteria) this;
 824         }
 825
 826         /**
 827          * <br>
 828          *
 829          * @param value
 830          * @return
 831          */
 832         public Criteria andJobIdEqualTo(String value) {
 833             addCriterion("JOB_ID =", value, JOB_ID);
 834             return (Criteria) this;
 835         }
 836
 837         /**
 838          * <br>
 839          *
 840          * @param value
 841          * @return
 842          */
 843         public Criteria andJobIdNotEqualTo(String value) {
 844             addCriterion("JOB_ID <>", value, JOB_ID);
 845             return (Criteria) this;
 846         }
 847
 848         /**
 849          * <br>
 850          *
 851          * @param value
 852          * @return
 853          */
 854         public Criteria andJobIdGreaterThan(String value) {
 855             addCriterion("JOB_ID >", value, JOB_ID);
 856             return (Criteria) this;
 857         }
 858
 859         /**
 860          * <br>
 861          *
 862          * @param value
 863          * @return
 864          */
 865         public Criteria andJobIdGreaterThanOrEqualTo(String value) {
 866             addCriterion("JOB_ID >=", value, JOB_ID);
 867             return (Criteria) this;
 868         }
 869
 870         /**
 871          * <br>
 872          *
 873          * @param value
 874          * @return
 875          */
 876         public Criteria andJobIdLessThan(String value) {
 877             addCriterion("JOB_ID <", value, JOB_ID);
 878             return (Criteria) this;
 879         }
 880
 881         /**
 882          * <br>
 883          *
 884          * @param value
 885          * @return
 886          */
 887         public Criteria andJobIdLessThanOrEqualTo(String value) {
 888             addCriterion("JOB_ID <=", value, JOB_ID);
 889             return (Criteria) this;
 890         }
 891
 892         /**
 893          * <br>
 894          *
 895          * @param value
 896          * @return
 897          */
 898         public Criteria andJobIdLike(String value) {
 899             addCriterion("JOB_ID like", value, JOB_ID);
 900             return (Criteria) this;
 901         }
 902
 903         /**
 904          * <br>
 905          *
 906          * @param value
 907          * @return
 908          */
 909         public Criteria andJobIdNotLike(String value) {
 910             addCriterion("JOB_ID not like", value, JOB_ID);
 911             return (Criteria) this;
 912         }
 913
 914         /**
 915          * <br>
 916          *
 917          * @param values
 918          * @return
 919          */
 920         public Criteria andJobIdIn(List<String> values) {
 921             addCriterion("JOB_ID in", values, JOB_ID);
 922             return (Criteria) this;
 923         }
 924
 925         /**
 926          * <br>
 927          *
 928          * @param values
 929          * @return
 930          */
 931         public Criteria andJobIdNotIn(List<String> values) {
 932             addCriterion("JOB_ID not in", values, JOB_ID);
 933             return (Criteria) this;
 934         }
 935
 936         /**
 937          * <br>
 938          *
 939          * @param value1
 940          * @param value2
 941          * @return
 942          */
 943         public Criteria andJobIdBetween(String value1, String value2) {
 944             addCriterion("JOB_ID between", value1, value2, JOB_ID);
 945             return (Criteria) this;
 946         }
 947
 948         /**
 949          * <br>
 950          *
 951          * @param value1
 952          * @param value2
 953          * @return
 954          */
 955         public Criteria andJobIdNotBetween(String value1, String value2) {
 956             addCriterion("JOB_ID not between", value1, value2, JOB_ID);
 957             return (Criteria) this;
 958         }
 959
 960         /**
 961          * <br>
 962          *
 963          * @return
 964          */
 965         public Criteria andStatusIsNull() {
 966             addCriterion("STATUS is null");
 967             return (Criteria) this;
 968         }
 969
 970         /**
 971          * <br>
 972          *
 973          * @return
 974          */
 975         public Criteria andStatusIsNotNull() {
 976             addCriterion("STATUS is not null");
 977             return (Criteria) this;
 978         }
 979
 980         /**
 981          * <br>
 982          *
 983          * @param value
 984          * @return
 985          */
 986         public Criteria andStatusEqualTo(Integer value) {
 987             addCriterion("STATUS =", value, STATUS);
 988             return (Criteria) this;
 989         }
 990
 991         /**
 992          * <br>
 993          *
 994          * @param value
 995          * @return
 996          */
 997         public Criteria andStatusNotEqualTo(Integer value) {
 998             addCriterion("STATUS <>", value, STATUS);
 999             return (Criteria) this;
1000         }
1001
1002         /**
1003          * <br>
1004          *
1005          * @param value
1006          * @return
1007          */
1008         public Criteria andStatusGreaterThan(Integer value) {
1009             addCriterion("STATUS >", value, STATUS);
1010             return (Criteria) this;
1011         }
1012
1013         /**
1014          * <br>
1015          *
1016          * @param value
1017          * @return
1018          */
1019         public Criteria andStatusGreaterThanOrEqualTo(Integer value) {
1020             addCriterion("STATUS >=", value, STATUS);
1021             return (Criteria) this;
1022         }
1023
1024         /**
1025          * <br>
1026          *
1027          * @param value
1028          * @return
1029          */
1030         public Criteria andStatusLessThan(Integer value) {
1031             addCriterion("STATUS <", value, STATUS);
1032             return (Criteria) this;
1033         }
1034
1035         /**
1036          * <br>
1037          *
1038          * @param value
1039          * @return
1040          */
1041         public Criteria andStatusLessThanOrEqualTo(Integer value) {
1042             addCriterion("STATUS <=", value, STATUS);
1043             return (Criteria) this;
1044         }
1045
1046         /**
1047          * <br>
1048          *
1049          * @param values
1050          * @return
1051          */
1052         public Criteria andStatusIn(List<Integer> values) {
1053             addCriterion("STATUS in", values, STATUS);
1054             return (Criteria) this;
1055         }
1056
1057         /**
1058          * <br>
1059          *
1060          * @param values
1061          * @return
1062          */
1063         public Criteria andStatusNotIn(List<Integer> values) {
1064             addCriterion("STATUS not in", values, STATUS);
1065             return (Criteria) this;
1066         }
1067
1068         /**
1069          * <br>
1070          *
1071          * @param value1
1072          * @param value2
1073          * @return
1074          */
1075         public Criteria andStatusBetween(Integer value1, Integer value2) {
1076             addCriterion("STATUS between", value1, value2, STATUS);
1077             return (Criteria) this;
1078         }
1079
1080         /**
1081          * <br>
1082          *
1083          * @param value1
1084          * @param value2
1085          * @return
1086          */
1087         public Criteria andStatusNotBetween(Integer value1, Integer value2) {
1088             addCriterion("STATUS not between", value1, value2, STATUS);
1089             return (Criteria) this;
1090         }
1091
1092         /**
1093          * <br>
1094          *
1095          * @return
1096          */
1097         public Criteria andCreateTimeIsNull() {
1098             addCriterion("CREATE_TIME is null");
1099             return (Criteria) this;
1100         }
1101
1102         /**
1103          * <br>
1104          *
1105          * @return
1106          */
1107         public Criteria andCreateTimeIsNotNull() {
1108             addCriterion("CREATE_TIME is not null");
1109             return (Criteria) this;
1110         }
1111
1112         /**
1113          * <br>
1114          *
1115          * @param value
1116          * @return
1117          */
1118         public Criteria andCreateTimeEqualTo(Date value) {
1119             addCriterion("CREATE_TIME =", value, CREATE_TIME);
1120             return (Criteria) this;
1121         }
1122
1123         /**
1124          * <br>
1125          *
1126          * @param value
1127          * @return
1128          */
1129         public Criteria andCreateTimeNotEqualTo(Date value) {
1130             addCriterion("CREATE_TIME <>", value, CREATE_TIME);
1131             return (Criteria) this;
1132         }
1133
1134         /**
1135          * <br>
1136          *
1137          * @param value
1138          * @return
1139          */
1140         public Criteria andCreateTimeGreaterThan(Date value) {
1141             addCriterion("CREATE_TIME >", value, CREATE_TIME);
1142             return (Criteria) this;
1143         }
1144
1145         /**
1146          * <br>
1147          *
1148          * @param value
1149          * @return
1150          */
1151         public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
1152             addCriterion("CREATE_TIME >=", value, CREATE_TIME);
1153             return (Criteria) this;
1154         }
1155
1156         /**
1157          * <br>
1158          *
1159          * @param value
1160          * @return
1161          */
1162         public Criteria andCreateTimeLessThan(Date value) {
1163             addCriterion("CREATE_TIME <", value, CREATE_TIME);
1164             return (Criteria) this;
1165         }
1166
1167         /**
1168          * <br>
1169          *
1170          * @param value
1171          * @return
1172          */
1173         public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
1174             addCriterion("CREATE_TIME <=", value, CREATE_TIME);
1175             return (Criteria) this;
1176         }
1177
1178         /**
1179          * <br>
1180          *
1181          * @param values
1182          * @return
1183          */
1184         public Criteria andCreateTimeIn(List<Date> values) {
1185             addCriterion("CREATE_TIME in", values, CREATE_TIME);
1186             return (Criteria) this;
1187         }
1188
1189         /**
1190          * <br>
1191          *
1192          * @param values
1193          * @return
1194          */
1195         public Criteria andCreateTimeNotIn(List<Date> values) {
1196             addCriterion("CREATE_TIME not in", values, CREATE_TIME);
1197             return (Criteria) this;
1198         }
1199
1200         /**
1201          * <br>
1202          *
1203          * @param value1
1204          * @param value2
1205          * @return
1206          */
1207         public Criteria andCreateTimeBetween(Date value1, Date value2) {
1208             addCriterion("CREATE_TIME between", value1, value2, CREATE_TIME);
1209             return (Criteria) this;
1210         }
1211
1212         /**
1213          * <br>
1214          *
1215          * @param value1
1216          * @param value2
1217          * @return
1218          */
1219         public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
1220             addCriterion("CREATE_TIME not between", value1, value2, CREATE_TIME);
1221             return (Criteria) this;
1222         }
1223
1224         /**
1225          * <br>
1226          *
1227          * @return
1228          */
1229         public Criteria andModifyTimeIsNull() {
1230             addCriterion("MODIFY_TIME is null");
1231             return (Criteria) this;
1232         }
1233
1234         /**
1235          * <br>
1236          *
1237          * @return
1238          */
1239         public Criteria andModifyTimeIsNotNull() {
1240             addCriterion("MODIFY_TIME is not null");
1241             return (Criteria) this;
1242         }
1243
1244         /**
1245          * <br>
1246          *
1247          * @param value
1248          * @return
1249          */
1250         public Criteria andModifyTimeEqualTo(Date value) {
1251             addCriterion("MODIFY_TIME =", value, MODIFY_TIME);
1252             return (Criteria) this;
1253         }
1254
1255         /**
1256          * <br>
1257          *
1258          * @param value
1259          * @return
1260          */
1261         public Criteria andModifyTimeNotEqualTo(Date value) {
1262             addCriterion("MODIFY_TIME <>", value, MODIFY_TIME);
1263             return (Criteria) this;
1264         }
1265
1266         /**
1267          * <br>
1268          *
1269          * @param value
1270          * @return
1271          */
1272         public Criteria andModifyTimeGreaterThan(Date value) {
1273             addCriterion("MODIFY_TIME >", value, MODIFY_TIME);
1274             return (Criteria) this;
1275         }
1276
1277         /**
1278          * <br>
1279          *
1280          * @param value
1281          * @return
1282          */
1283         public Criteria andModifyTimeGreaterThanOrEqualTo(Date value) {
1284             addCriterion("MODIFY_TIME >=", value, MODIFY_TIME);
1285             return (Criteria) this;
1286         }
1287
1288         /**
1289          * <br>
1290          *
1291          * @param value
1292          * @return
1293          */
1294         public Criteria andModifyTimeLessThan(Date value) {
1295             addCriterion("MODIFY_TIME <", value, MODIFY_TIME);
1296             return (Criteria) this;
1297         }
1298
1299         /**
1300          * <br>
1301          *
1302          * @param value
1303          * @return
1304          */
1305         public Criteria andModifyTimeLessThanOrEqualTo(Date value) {
1306             addCriterion("MODIFY_TIME <=", value, MODIFY_TIME);
1307             return (Criteria) this;
1308         }
1309
1310         /**
1311          * <br>
1312          *
1313          * @param values
1314          * @return
1315          */
1316         public Criteria andModifyTimeIn(List<Date> values) {
1317             addCriterion("MODIFY_TIME in", values, MODIFY_TIME);
1318             return (Criteria) this;
1319         }
1320
1321         /**
1322          * <br>
1323          *
1324          * @param values
1325          * @return
1326          */
1327         public Criteria andModifyTimeNotIn(List<Date> values) {
1328             addCriterion("MODIFY_TIME not in", values, MODIFY_TIME);
1329             return (Criteria) this;
1330         }
1331
1332         /**
1333          * <br>
1334          *
1335          * @param value1
1336          * @param value2
1337          * @return
1338          */
1339         public Criteria andModifyTimeBetween(Date value1, Date value2) {
1340             addCriterion("MODIFY_TIME between", value1, value2, MODIFY_TIME);
1341             return (Criteria) this;
1342         }
1343
1344         /**
1345          * <br>
1346          *
1347          * @param value1
1348          * @param value2
1349          * @return
1350          */
1351         public Criteria andModifyTimeNotBetween(Date value1, Date value2) {
1352             addCriterion("MODIFY_TIME not between", value1, value2, MODIFY_TIME);
1353             return (Criteria) this;
1354         }
1355
1356         /**
1357          * <br>
1358          *
1359          * @return
1360          */
1361         public Criteria andDeleteTimeIsNull() {
1362             addCriterion("DELETE_TIME is null");
1363             return (Criteria) this;
1364         }
1365
1366         /**
1367          * <br>
1368          *
1369          * @return
1370          */
1371         public Criteria andDeleteTimeIsNotNull() {
1372             addCriterion("DELETE_TIME is not null");
1373             return (Criteria) this;
1374         }
1375
1376         /**
1377          * <br>
1378          *
1379          * @param value
1380          * @return
1381          */
1382         public Criteria andDeleteTimeEqualTo(Date value) {
1383             addCriterion("DELETE_TIME =", value, DELETE_TIME);
1384             return (Criteria) this;
1385         }
1386
1387         /**
1388          * <br>
1389          *
1390          * @param value
1391          * @return
1392          */
1393         public Criteria andDeleteTimeNotEqualTo(Date value) {
1394             addCriterion("DELETE_TIME <>", value, DELETE_TIME);
1395             return (Criteria) this;
1396         }
1397
1398         /**
1399          * <br>
1400          *
1401          * @param value
1402          * @return
1403          */
1404         public Criteria andDeleteTimeGreaterThan(Date value) {
1405             addCriterion("DELETE_TIME >", value, DELETE_TIME);
1406             return (Criteria) this;
1407         }
1408
1409         /**
1410          * <br>
1411          *
1412          * @param value
1413          * @return
1414          */
1415         public Criteria andDeleteTimeGreaterThanOrEqualTo(Date value) {
1416             addCriterion("DELETE_TIME >=", value, DELETE_TIME);
1417             return (Criteria) this;
1418         }
1419
1420         /**
1421          * <br>
1422          *
1423          * @param value
1424          * @return
1425          */
1426         public Criteria andDeleteTimeLessThan(Date value) {
1427             addCriterion("DELETE_TIME <", value, DELETE_TIME);
1428             return (Criteria) this;
1429         }
1430
1431         /**
1432          * <br>
1433          *
1434          * @param value
1435          * @return
1436          */
1437         public Criteria andDeleteTimeLessThanOrEqualTo(Date value) {
1438             addCriterion("DELETE_TIME <=", value, DELETE_TIME);
1439             return (Criteria) this;
1440         }
1441
1442         /**
1443          * <br>
1444          *
1445          * @param values
1446          * @return
1447          */
1448         public Criteria andDeleteTimeIn(List<Date> values) {
1449             addCriterion("DELETE_TIME in", values, DELETE_TIME);
1450             return (Criteria) this;
1451         }
1452
1453         /**
1454          * <br>
1455          *
1456          * @param values
1457          * @return
1458          */
1459         public Criteria andDeleteTimeNotIn(List<Date> values) {
1460             addCriterion("DELETE_TIME not in", values, DELETE_TIME);
1461             return (Criteria) this;
1462         }
1463
1464         /**
1465          * <br>
1466          *
1467          * @param value1
1468          * @param value2
1469          * @return
1470          */
1471         public Criteria andDeleteTimeBetween(Date value1, Date value2) {
1472             addCriterion("DELETE_TIME between", value1, value2, DELETE_TIME);
1473             return (Criteria) this;
1474         }
1475
1476         /**
1477          * <br>
1478          *
1479          * @param value1
1480          * @param value2
1481          * @return
1482          */
1483         public Criteria andDeleteTimeNotBetween(Date value1, Date value2) {
1484             addCriterion("DELETE_TIME not between", value1, value2, DELETE_TIME);
1485             return (Criteria) this;
1486         }
1487     }
1488
1489     /**
1490      * <br>
1491      * <p>
1492      * </p>
1493      *
1494      * @author z00292420
1495      * @date 2016-9-14
1496      */
1497     public static class Criteria extends GeneratedCriteria {
1498
1499         protected Criteria() {
1500             super();
1501         }
1502     }
1503
1504     /**
1505      * Criterion
1506      * .</br>
1507      *
1508      * @author
1509      * @version     NFVO 0.5  Sep 14, 2016
1510      */
1511     public static class Criterion {
1512         private String condition;
1513
1514         private Object value;
1515
1516         private Object secondValue;
1517
1518         private boolean noValue;
1519
1520         private boolean singleValue;
1521
1522         private boolean betweenValue;
1523
1524         private boolean listValue;
1525
1526         private String typeHandler;
1527
1528
1529
1530         /**
1531          * Constructor<br/>
1532          * <p>
1533          * </p>
1534          *
1535          * @param condition
1536          */
1537         protected Criterion(String condition) {
1538             super();
1539             this.condition = condition;
1540             this.typeHandler = null;
1541             this.noValue = true;
1542         }
1543
1544         /**
1545          * Constructor<br/>
1546          * <p>
1547          * </p>
1548          *
1549          * @param condition
1550          * @param value
1551          * @param typeHandler
1552          */
1553         protected Criterion(String condition, Object value, String typeHandler) {
1554             super();
1555             this.condition = condition;
1556             this.value = value;
1557             this.typeHandler = typeHandler;
1558             if (value instanceof List<?>) {
1559                 this.listValue = true;
1560             } else {
1561                 this.singleValue = true;
1562             }
1563         }
1564
1565         /**
1566          * Constructor<br/>
1567          * <p>
1568          * </p>
1569          *
1570          * @param condition
1571          * @param value
1572          */
1573         protected Criterion(String condition, Object value) {
1574             this(condition, value, null);
1575         }
1576
1577         /**
1578          * Constructor<br/>
1579          * <p>
1580          * </p>
1581          *
1582          * @param condition
1583          * @param value
1584          * @param secondValue
1585          * @param typeHandler
1586          */
1587         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
1588             super();
1589             this.condition = condition;
1590             this.value = value;
1591             this.secondValue = secondValue;
1592             this.typeHandler = typeHandler;
1593             this.betweenValue = true;
1594         }
1595
1596         /**
1597          * Constructor<br/>
1598          * <p>
1599          * </p>
1600          *
1601          * @param condition
1602          * @param value
1603          * @param secondValue
1604          */
1605         protected Criterion(String condition, Object value, Object secondValue) {
1606             this(condition, value, secondValue, null);
1607         }
1608
1609
1610         /**
1611          * <br>
1612          *
1613          * @return
1614          */
1615         public String getCondition() {
1616             return condition;
1617         }
1618
1619         /**
1620          * <br>
1621          *
1622          * @return
1623          */
1624         public Object getValue() {
1625             return value;
1626         }
1627
1628         /**
1629          * <br>
1630          *
1631          * @return
1632          */
1633         public Object getSecondValue() {
1634             return secondValue;
1635         }
1636
1637         /**
1638          * <br>
1639          *
1640          * @return
1641          */
1642         public boolean isNoValue() {
1643             return noValue;
1644         }
1645
1646         /**
1647          * <br>
1648          *
1649          * @return
1650          */
1651         public boolean isSingleValue() {
1652             return singleValue;
1653         }
1654
1655         /**
1656          * <br>
1657          *
1658          * @return
1659          */
1660         public boolean isBetweenValue() {
1661             return betweenValue;
1662         }
1663
1664         /**
1665          * <br>
1666          *
1667          * @return
1668          */
1669         public boolean isListValue() {
1670             return listValue;
1671         }
1672
1673         /**
1674          * <br>
1675          *
1676          * @return
1677          */
1678         public String getTypeHandler() {
1679             return typeHandler;
1680         }
1681     }
1682 }