@Override
  public List<CompilationUnit> getCompilationUnits() {
    FullyQualifiedTable table = introspectedTable.getFullyQualifiedTable();
    progressCallback.startTask(getString("Progress.9", table.toString())); // $NON-NLS-1$
    Plugin plugins = context.getPlugins();
    CommentGenerator commentGenerator = context.getCommentGenerator();

    TopLevelClass topLevelClass = new TopLevelClass(introspectedTable.getRecordWithBLOBsType());
    topLevelClass.setVisibility(JavaVisibility.PUBLIC);
    commentGenerator.addJavaFileComment(topLevelClass);

    topLevelClass.addJavaDocLine("/**");
    topLevelClass.addJavaDocLine("* " + table.getDomainObjectName());
    topLevelClass.addJavaDocLine("* table:" + table.getIntrospectedTableName());
    topLevelClass.addJavaDocLine("* ");
    topLevelClass.addJavaDocLine("* @author 王欣");
    topLevelClass.addJavaDocLine("* @version v1.0");
    // topLevelClass.addJavaDocLine("* @copy 鸿旭图码");
    topLevelClass.addJavaDocLine("* @copy wangxin");
    topLevelClass.addJavaDocLine(
        "* @date " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    topLevelClass.addJavaDocLine("*/");

    String rootClass = getRootClass();
    if (introspectedTable.getRules().generateBaseRecordClass()) {
      topLevelClass.setSuperClass(introspectedTable.getBaseRecordType());
    } else {
      topLevelClass.setSuperClass(introspectedTable.getPrimaryKeyType());
    }

    if (introspectedTable.isConstructorBased()) {
      addParameterizedConstructor(topLevelClass);

      if (!introspectedTable.isImmutable()) {
        addDefaultConstructor(topLevelClass);
      }
    }

    for (IntrospectedColumn introspectedColumn : introspectedTable.getBLOBColumns()) {
      if (RootClassInfo.getInstance(rootClass, warnings).containsProperty(introspectedColumn)) {
        continue;
      }

      Field field = getJavaBeansField(introspectedColumn);
      if (plugins.modelFieldGenerated(
          field,
          topLevelClass,
          introspectedColumn,
          introspectedTable,
          Plugin.ModelClassType.RECORD_WITH_BLOBS)) {
        topLevelClass.addField(field);
        topLevelClass.addImportedType(field.getType());
      }

      Method method = getJavaBeansGetter(introspectedColumn);
      if (plugins.modelGetterMethodGenerated(
          method,
          topLevelClass,
          introspectedColumn,
          introspectedTable,
          Plugin.ModelClassType.RECORD_WITH_BLOBS)) {
        topLevelClass.addMethod(method);
      }

      if (!introspectedTable.isImmutable()) {
        method = getJavaBeansSetter(introspectedColumn);
        if (plugins.modelSetterMethodGenerated(
            method,
            topLevelClass,
            introspectedColumn,
            introspectedTable,
            Plugin.ModelClassType.RECORD_WITH_BLOBS)) {
          topLevelClass.addMethod(method);
        }
      }
    }

    List<CompilationUnit> answer = new ArrayList<CompilationUnit>();
    if (context.getPlugins().modelRecordWithBLOBsClassGenerated(topLevelClass, introspectedTable)) {
      answer.add(topLevelClass);
    }
    return answer;
  }
 private void addUpdateMethods(TopLevelClass topLevelClass, IntrospectedTable introspectedTable, MyBatisClasses cls, String base, String withBLOBs, boolean selective) {
     String record = cls.names.base;
     topLevelClass.addImportedType(cls.imports.base);
     String mapperMethod = selective ? "updateByExampleSelective" : "updateByExample";
     Rules r = introspectedTable.getRules();
     if (!base.startsWith(SKIP) && ( selective ? r.generateUpdateByExampleSelective() : r.generateUpdateByExampleWithoutBLOBs() )) {
         if (selective && r.generateRecordWithBLOBsClass()) {
             record = cls.names.blob;
             topLevelClass.addImportedType(cls.imports.blob);
         }
         topLevelClass.addMethod(method(
             PUBLIC, INT, base, _(sqlSession, "sql"), _(new FullyQualifiedJavaType(record), "record"), __(
                 "return sql.getMapper(" + cls.names.mapper + ".class)."+mapperMethod+"(record, this);"
         )));
         topLevelClass.addMethod(method(
             PUBLIC, INT, base, _(cls.types.mapper, "mapper"), _(new FullyQualifiedJavaType(record), "record"), __(
                 "return mapper."+mapperMethod+"(record, this);"
         )));
     }
     if (introspectedTable.hasBLOBColumns() && !withBLOBs.startsWith(SKIP) && !selective && r.generateUpdateByExampleWithBLOBs()) {
         if (r.generateRecordWithBLOBsClass()) {
             record = cls.names.blob;
             topLevelClass.addImportedType(cls.imports.blob);
         }
         mapperMethod = selective ? "updateByExampleSelectiveWithBLOBs" /* not supported */ : "updateByExampleWithBLOBs";
         topLevelClass.addMethod(method(
             PUBLIC, INT, withBLOBs, _(sqlSession, "sql"), _(new FullyQualifiedJavaType(record), "record"), __(
                 "return sql.getMapper(" + cls.names.mapper + ".class)."+mapperMethod+"(record, this);"
         )));
         topLevelClass.addMethod(method(
             PUBLIC, INT, withBLOBs, _(cls.types.mapper, "mapper"), _(new FullyQualifiedJavaType(record), "record"), __(
                 "return mapper."+mapperMethod+"(record, this);"
         )));
     }
 }
 private void addGetRecordMethods(TopLevelClass topLevelClass, IntrospectedTable introspectedTable, MyBatisClasses cls, String base, String withBLOBs, String expression) {
     String returnType = cls.names.base;
     topLevelClass.addImportedType(cls.imports.base);
     String listType = "java.util.List<"+returnType+">";
     if (!base.startsWith(SKIP) && introspectedTable.getRules().generateSelectByExampleWithoutBLOBs()) {
         topLevelClass.addMethod(method(
             PUBLIC, new FullyQualifiedJavaType(returnType), base, _(sqlSession, "sql"), __(
                 listType + " list = sql.getMapper(" + cls.names.mapper + ".class).selectByExample(this);",
                 "return "+expression.replace("@result", returnType)+";"
         )));
         topLevelClass.addMethod(method(
             PUBLIC, new FullyQualifiedJavaType(returnType), base, _(cls.types.mapper, "mapper"), __(
                 listType + " list = mapper.selectByExample(this);",
                 "return "+expression.replace("@result", returnType)+";"
         )));
     }
     if (introspectedTable.hasBLOBColumns() && !withBLOBs.startsWith(SKIP) && introspectedTable.getRules().generateSelectByExampleWithBLOBs()) {
         if (cls.exists.blob) {
             returnType = cls.names.blob;
             topLevelClass.addImportedType(cls.imports.blob);
         }
         listType = "java.util.List<"+returnType+">";
         topLevelClass.addMethod(method(
             PUBLIC, new FullyQualifiedJavaType(returnType), withBLOBs, _(sqlSession, "sql"), __(
                 listType + " list = sql.getMapper(" + cls.names.mapper + ".class).selectByExampleWithBLOBs(this);",
                 "return "+expression.replace("@result", returnType)+";"
         )));
         topLevelClass.addMethod(method(
             PUBLIC, new FullyQualifiedJavaType(returnType), withBLOBs, _(cls.types.mapper, "mapper"), __(
                 listType + " list = mapper.selectByExampleWithBLOBs(this);",
                 "return "+expression.replace("@result", returnType)+";"
         )));
     }
 }
 private void addListMethods(TopLevelClass topLevelClass, IntrospectedTable introspectedTable, MyBatisClasses cls) {
     String returnType = "java.util.List<"+cls.names.base+">";
     topLevelClass.addImportedType(cls.imports.base);
     if (!listMethod.startsWith(SKIP) && introspectedTable.getRules().generateSelectByExampleWithoutBLOBs()) {
         topLevelClass.addMethod(method(
             PUBLIC, new FullyQualifiedJavaType(returnType), listMethod, _(sqlSession, "sql"), __(
                 "return sql.getMapper(" + cls.names.mapper + ".class).selectByExample(this);"
         )));
         topLevelClass.addMethod(method(
             PUBLIC, new FullyQualifiedJavaType(returnType), listMethod, _(cls.types.mapper, "mapper"), __(
                 "return mapper.selectByExample(this);"
         )));
     }
     if (introspectedTable.hasBLOBColumns() && !listWithBLOBsMethod.startsWith(SKIP) && introspectedTable.getRules().generateSelectByExampleWithBLOBs()) {
         if (cls.exists.blob) {
             returnType = "java.util.List<" + cls.names.blob + ">";
             topLevelClass.addImportedType(cls.imports.blob);
         }
         topLevelClass.addMethod(method(
             PUBLIC, new FullyQualifiedJavaType(returnType), listWithBLOBsMethod, _(sqlSession, "sql"), __(
                 "return sql.getMapper("+cls.names.mapper+".class).selectByExampleWithBLOBs(this);"
         )));
         topLevelClass.addMethod(method(
             PUBLIC, new FullyQualifiedJavaType(returnType), listWithBLOBsMethod, _(cls.types.mapper, "mapper"), __(
                 "return mapper.selectByExampleWithBLOBs(this);"
         )));
     }
 }
    @Override
    public boolean modelExampleClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
        MyBatisClasses cls = MyBatisClasses.calculate(topLevelClass, introspectedTable);
        topLevelClass.addImportedType(sqlSession);
        if (cls.imports.mapper != null)
            topLevelClass.addImportedType(cls.imports.mapper);

        int newMethodsStart = topLevelClass.getMethods().size();

        addListMethods(topLevelClass, introspectedTable, cls);
        addGetRecordMethods(topLevelClass, introspectedTable, cls, firstMethod, firstWithBLOBsMethod, "list == null || list.isEmpty() ? null : list.get(0)");
        addGetRecordMethods(topLevelClass, introspectedTable, cls, singleMethod, singleWithBLOBsMethod, "list == null || list.size() != 1 ? null : list.get(0)");
        addGetRecordMethods(topLevelClass, introspectedTable, cls, optionalMethod, optionalWithBLOBsMethod, "list == null || list.isEmpty() ? new @result() : list.get(0)");
        addUpdateMethods(topLevelClass, introspectedTable, cls, updateMethod, updateWithBLOBsMethod, false);
        addUpdateMethods(topLevelClass, introspectedTable, cls, updateSelectiveMethod, updateSelectiveWithBLOBsMethod, true);
        addDeleteMethods(topLevelClass, introspectedTable, cls);
        addCountMethods(topLevelClass, introspectedTable, cls);
        if (mapperClass != null) {
            addUserDefinedMethods(topLevelClass, mapperClass, introspectedTable, cls);
            mapperClass = null;
            exampleClass = null;
        } else {
            exampleClass = topLevelClass;
        }

        addCriteriaMethods(topLevelClass, newMethodsStart);

        return true;
    }
 private void addLimit(
     TopLevelClass topLevelClass, IntrospectedTable introspectedTable, String name) {
   CommentGenerator commentGenerator = context.getCommentGenerator();
   FullyQualifiedJavaType limitType = new FullyQualifiedJavaType("com.tommy.common.Limit");
   topLevelClass.addImportedType(limitType);
   Field field = new Field();
   field.setVisibility(JavaVisibility.PROTECTED);
   field.setType(limitType);
   field.setName(name);
   commentGenerator.addFieldComment(field, introspectedTable);
   topLevelClass.addField(field);
   char c = name.charAt(0);
   String camel = Character.toUpperCase(c) + name.substring(1);
   Method method = new Method();
   method.setVisibility(JavaVisibility.PUBLIC);
   method.setName("set" + camel);
   method.addParameter(new Parameter(limitType, name));
   method.addBodyLine("this." + name + "=" + name + ";");
   commentGenerator.addGeneralMethodComment(method, introspectedTable);
   topLevelClass.addMethod(method);
   method = new Method();
   method.setVisibility(JavaVisibility.PUBLIC);
   method.setReturnType(limitType);
   method.setName("get" + camel);
   method.addBodyLine("return " + name + ";");
   commentGenerator.addGeneralMethodComment(method, introspectedTable);
   topLevelClass.addMethod(method);
 }
  /**
   * 添加实现类
   *
   * @param introspectedTable
   * @param tableName
   * @param files
   */
  protected void addServiceImpl(
      TopLevelClass topLevelClass,
      IntrospectedTable introspectedTable,
      String tableName,
      List<GeneratedJavaFile> files) {
    topLevelClass.setVisibility(JavaVisibility.PUBLIC);
    // 设置实现的接口
    topLevelClass.addSuperInterface(interfaceType);

    if (enableAnnotation) {
      topLevelClass.addAnnotation("@Service");
      topLevelClass.addImportedType(service);
    }
    // 添加引用dao
    addField(topLevelClass, tableName);
    // 添加方法
    topLevelClass.addMethod(countByExample(introspectedTable, tableName));
    topLevelClass.addMethod(selectByPrimaryKey(introspectedTable, tableName));
    topLevelClass.addMethod(selectByExample(introspectedTable, tableName));

    /** type 的意义 pojo 1 ;key 2 ;example 3 ;pojo+example 4 */
    if (enableDeleteByPrimaryKey) {
      topLevelClass.addMethod(
          getOtherInteger("deleteByPrimaryKey", introspectedTable, tableName, 2));
    }
    if (enableUpdateByPrimaryKeySelective) {
      topLevelClass.addMethod(
          getOtherInteger("updateByPrimaryKeySelective", introspectedTable, tableName, 1));
    }
    if (enableUpdateByPrimaryKey) {
      topLevelClass.addMethod(
          getOtherInteger("updateByPrimaryKey", introspectedTable, tableName, 1));
    }
    if (enableDeleteByExample) {
      topLevelClass.addMethod(getOtherInteger("deleteByExample", introspectedTable, tableName, 3));
    }
    if (enableUpdateByExampleSelective) {
      topLevelClass.addMethod(
          getOtherInteger("updateByExampleSelective", introspectedTable, tableName, 4));
    }
    if (enableUpdateByExample) {
      topLevelClass.addMethod(getOtherInteger("updateByExample", introspectedTable, tableName, 4));
    }
    if (enableInsert) {
      topLevelClass.addMethod(getOtherInsertboolean("insert", introspectedTable, tableName));
    }
    if (enableInsertSelective) {
      topLevelClass.addMethod(
          getOtherInsertboolean("insertSelective", introspectedTable, tableName));
    }
    // 生成文件
    GeneratedJavaFile file =
        new GeneratedJavaFile(
            topLevelClass,
            project,
            context.getProperty(PropertyRegistry.CONTEXT_JAVA_FILE_ENCODING),
            context.getJavaFormatter());
    files.add(file);
  }
 /** 导入需要的类 */
 private void addImport(Interface interfaces, TopLevelClass topLevelClass) {
   interfaces.addImportedType(pojoType);
   interfaces.addImportedType(pojoCriteriaType);
   interfaces.addImportedType(listType);
   topLevelClass.addImportedType(daoType);
   topLevelClass.addImportedType(interfaceType);
   topLevelClass.addImportedType(pojoType);
   topLevelClass.addImportedType(pojoCriteriaType);
   topLevelClass.addImportedType(listType);
   topLevelClass.addImportedType(slf4jLogger);
   topLevelClass.addImportedType(slf4jLoggerFactory);
   if (enableAnnotation) {
     topLevelClass.addImportedType(service);
     topLevelClass.addImportedType(autowired);
   }
 }
 /**
  * 添加字段
  *
  * @param topLevelClass
  */
 protected void addField(TopLevelClass topLevelClass, String tableName) {
   // 添加 dao
   Field field = new Field();
   field.setName(toLowerCase(daoType.getShortName())); // 设置变量名
   topLevelClass.addImportedType(daoType);
   field.setType(daoType); // 类型
   field.setVisibility(JavaVisibility.PRIVATE);
   if (enableAnnotation) {
     field.addAnnotation("@Autowired");
   }
   topLevelClass.addField(field);
 }
Example #10
0
  protected void makeSerializable(
      TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
    if (addGWTInterface) {
      topLevelClass.addImportedType(gwtSerializable);
      topLevelClass.addSuperInterface(gwtSerializable);
    }

    if (!suppressJavaInterface) {
      topLevelClass.addImportedType(serializable);
      topLevelClass.addSuperInterface(serializable);

      Field field = new Field();
      field.setFinal(true);
      field.setInitializationString("1L"); // $NON-NLS-1$
      field.setName("serialVersionUID"); // $NON-NLS-1$
      field.setStatic(true);
      field.setType(new FullyQualifiedJavaType("long")); // $NON-NLS-1$
      field.setVisibility(JavaVisibility.PRIVATE);
      context.getCommentGenerator().addFieldComment(field, introspectedTable);

      topLevelClass.addField(field);
    }
  }
  @Override
  public boolean modelBaseRecordClassGenerated(
      TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
    topLevelClass.addImportedType("java.io.Serializable");
    topLevelClass.addSuperInterface(new FullyQualifiedJavaType("java.io.Serializable"));

    Field field = new Field();
    // private static final long serialVersionUID = 1L;
    field.setName("serialVersionUID");
    field.setType(new FullyQualifiedJavaType("long"));
    field.setStatic(true);
    field.setFinal(true);
    field.setInitializationString("1L");
    topLevelClass.addField(field);
    return super.modelBaseRecordClassGenerated(topLevelClass, introspectedTable);
  }
  private InnerClass getGeneratedCriteriaInnerClass(TopLevelClass topLevelClass) {
    Field field;
    Method method;

    InnerClass answer = new InnerClass(FullyQualifiedJavaType.getGeneratedCriteriaInstance());

    answer.setVisibility(JavaVisibility.PROTECTED);
    answer.setStatic(true);
    answer.setAbstract(true);
    context.getCommentGenerator().addClassComment(answer, introspectedTable);

    method = new Method();
    method.setVisibility(JavaVisibility.PROTECTED);
    method.setName("GeneratedCriteria"); // $NON-NLS-1$
    method.setConstructor(true);
    method.addBodyLine("super();"); // $NON-NLS-1$
    method.addBodyLine("criteria = new ArrayList<Criterion>();"); // $NON-NLS-1$
    answer.addMethod(method);

    List<String> criteriaLists = new ArrayList<String>();
    criteriaLists.add("criteria"); // $NON-NLS-1$

    for (IntrospectedColumn introspectedColumn : introspectedTable.getNonBLOBColumns()) {
      if (stringHasValue(introspectedColumn.getTypeHandler())) {
        String name = addtypeHandledObjectsAndMethods(introspectedColumn, method, answer);
        criteriaLists.add(name);
      }
    }

    // now generate the isValid method
    method = new Method();
    method.setVisibility(JavaVisibility.PUBLIC);
    method.setName("isValid"); // $NON-NLS-1$
    method.setReturnType(FullyQualifiedJavaType.getBooleanPrimitiveInstance());
    StringBuilder sb = new StringBuilder();
    Iterator<String> strIter = criteriaLists.iterator();
    sb.append("return "); // $NON-NLS-1$
    sb.append(strIter.next());
    sb.append(".size() > 0"); // $NON-NLS-1$
    if (!strIter.hasNext()) {
      sb.append(';');
    }
    method.addBodyLine(sb.toString());
    while (strIter.hasNext()) {
      sb.setLength(0);
      OutputUtilities.javaIndent(sb, 1);
      sb.append("|| "); // $NON-NLS-1$
      sb.append(strIter.next());
      sb.append(".size() > 0"); // $NON-NLS-1$
      if (!strIter.hasNext()) {
        sb.append(';');
      }
      method.addBodyLine(sb.toString());
    }
    answer.addMethod(method);

    // now generate the getAllCriteria method
    if (criteriaLists.size() > 1) {
      field = new Field();
      field.setName("allCriteria"); // $NON-NLS-1$
      field.setType(new FullyQualifiedJavaType("List<Criterion>")); // $NON-NLS-1$
      field.setVisibility(JavaVisibility.PROTECTED);
      answer.addField(field);
    }

    method = new Method();
    method.setVisibility(JavaVisibility.PUBLIC);
    method.setName("getAllCriteria"); // $NON-NLS-1$
    method.setReturnType(new FullyQualifiedJavaType("List<Criterion>")); // $NON-NLS-1$
    if (criteriaLists.size() < 2) {
      method.addBodyLine("return criteria;"); // $NON-NLS-1$
    } else {
      method.addBodyLine("if (allCriteria == null) {"); // $NON-NLS-1$
      method.addBodyLine("allCriteria = new ArrayList<Criterion>();"); // $NON-NLS-1$

      strIter = criteriaLists.iterator();
      while (strIter.hasNext()) {
        method.addBodyLine(String.format("allCriteria.addAll(%s);", strIter.next())); // $NON-NLS-1$
      }

      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine("return allCriteria;"); // $NON-NLS-1$
    }
    answer.addMethod(method);

    // now we need to generate the methods that will be used in the SqlMap
    // to generate the dynamic where clause
    topLevelClass.addImportedType(FullyQualifiedJavaType.getNewListInstance());
    topLevelClass.addImportedType(FullyQualifiedJavaType.getNewArrayListInstance());

    field = new Field();
    field.setVisibility(JavaVisibility.PROTECTED);
    FullyQualifiedJavaType listOfCriterion =
        new FullyQualifiedJavaType("java.util.List<Criterion>"); // $NON-NLS-1$
    field.setType(listOfCriterion);
    field.setName("criteria"); // $NON-NLS-1$
    answer.addField(field);

    method = new Method();
    method.setVisibility(JavaVisibility.PUBLIC);
    method.setReturnType(field.getType());
    method.setName(getGetterMethodName(field.getName(), field.getType()));
    method.addBodyLine("return criteria;"); // $NON-NLS-1$
    answer.addMethod(method);

    // now add the methods for simplifying the individual field set methods
    method = new Method();
    method.setVisibility(JavaVisibility.PROTECTED);
    method.setName("addCriterion"); // $NON-NLS-1$
    method.addParameter(
        new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
    method.addBodyLine("if (condition == null) {"); // $NON-NLS-1$
    method.addBodyLine(
        "throw new RuntimeException(\"Value for condition cannot be null\");"); //$NON-NLS-1$
    method.addBodyLine("}"); // $NON-NLS-1$
    method.addBodyLine("criteria.add(new Criterion(condition));"); // $NON-NLS-1$
    if (criteriaLists.size() > 1) {
      method.addBodyLine("allCriteria = null;"); // $NON-NLS-1$
    }
    answer.addMethod(method);

    method = new Method();
    method.setVisibility(JavaVisibility.PROTECTED);
    method.setName("addCriterion"); // $NON-NLS-1$
    method.addParameter(
        new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
    method.addParameter(
        new Parameter(FullyQualifiedJavaType.getObjectInstance(), "value")); // $NON-NLS-1$
    method.addParameter(
        new Parameter(FullyQualifiedJavaType.getStringInstance(), "property")); // $NON-NLS-1$
    method.addBodyLine("if (value == null) {"); // $NON-NLS-1$
    method.addBodyLine(
        "throw new RuntimeException(\"Value for \" + property + \" cannot be null\");"); //$NON-NLS-1$
    method.addBodyLine("}"); // $NON-NLS-1$
    method.addBodyLine("criteria.add(new Criterion(condition, value));"); // $NON-NLS-1$
    if (criteriaLists.size() > 1) {
      method.addBodyLine("allCriteria = null;"); // $NON-NLS-1$
    }
    answer.addMethod(method);

    method = new Method();
    method.setVisibility(JavaVisibility.PROTECTED);
    method.setName("addCriterion"); // $NON-NLS-1$
    method.addParameter(
        new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
    method.addParameter(
        new Parameter(FullyQualifiedJavaType.getObjectInstance(), "value1")); // $NON-NLS-1$
    method.addParameter(
        new Parameter(FullyQualifiedJavaType.getObjectInstance(), "value2")); // $NON-NLS-1$
    method.addParameter(
        new Parameter(FullyQualifiedJavaType.getStringInstance(), "property")); // $NON-NLS-1$
    method.addBodyLine("if (value1 == null || value2 == null) {"); // $NON-NLS-1$
    method.addBodyLine(
        "throw new RuntimeException(\"Between values for \" + property + \" cannot be null\");"); //$NON-NLS-1$
    method.addBodyLine("}"); // $NON-NLS-1$
    method.addBodyLine("criteria.add(new Criterion(condition, value1, value2));"); // $NON-NLS-1$
    if (criteriaLists.size() > 1) {
      method.addBodyLine("allCriteria = null;"); // $NON-NLS-1$
    }
    answer.addMethod(method);

    FullyQualifiedJavaType listOfDates =
        new FullyQualifiedJavaType("java.util.List<java.util.Date>"); // $NON-NLS-1$

    if (introspectedTable.hasJDBCDateColumns()) {
      topLevelClass.addImportedType(FullyQualifiedJavaType.getDateInstance());
      topLevelClass.addImportedType(FullyQualifiedJavaType.getNewIteratorInstance());
      method = new Method();
      method.setVisibility(JavaVisibility.PROTECTED);
      method.setName("addCriterionForJDBCDate"); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getDateInstance(), "value")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "property")); // $NON-NLS-1$
      method.addBodyLine("if (value == null) {"); // $NON-NLS-1$
      method.addBodyLine(
          "throw new RuntimeException(\"Value for \" + property + \" cannot be null\");"); //$NON-NLS-1$
      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine(
          "addCriterion(condition, new java.sql.Date(value.getTime()), property);"); //$NON-NLS-1$
      answer.addMethod(method);

      method = new Method();
      method.setVisibility(JavaVisibility.PROTECTED);
      method.setName("addCriterionForJDBCDate"); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
      method.addParameter(new Parameter(listOfDates, "values")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "property")); // $NON-NLS-1$
      method.addBodyLine("if (values == null || values.size() == 0) {"); // $NON-NLS-1$
      method.addBodyLine(
          "throw new RuntimeException(\"Value list for \" + property + \" cannot be null or empty\");"); //$NON-NLS-1$
      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine(
          "List<java.sql.Date> dateList = new ArrayList<java.sql.Date>();"); //$NON-NLS-1$
      method.addBodyLine("Iterator<Date> iter = values.iterator();"); // $NON-NLS-1$
      method.addBodyLine("while (iter.hasNext()) {"); // $NON-NLS-1$
      method.addBodyLine("dateList.add(new java.sql.Date(iter.next().getTime()));"); // $NON-NLS-1$
      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine("addCriterion(condition, dateList, property);"); // $NON-NLS-1$
      answer.addMethod(method);

      method = new Method();
      method.setVisibility(JavaVisibility.PROTECTED);
      method.setName("addCriterionForJDBCDate"); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getDateInstance(), "value1")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getDateInstance(), "value2")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "property")); // $NON-NLS-1$
      method.addBodyLine("if (value1 == null || value2 == null) {"); // $NON-NLS-1$
      method.addBodyLine(
          "throw new RuntimeException(\"Between values for \" + property + \" cannot be null\");"); //$NON-NLS-1$
      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine(
          "addCriterion(condition, new java.sql.Date(value1.getTime()), new java.sql.Date(value2.getTime()), property);"); //$NON-NLS-1$
      answer.addMethod(method);
    }

    if (introspectedTable.hasJDBCTimeColumns()) {
      topLevelClass.addImportedType(FullyQualifiedJavaType.getDateInstance());
      topLevelClass.addImportedType(FullyQualifiedJavaType.getNewIteratorInstance());
      method = new Method();
      method.setVisibility(JavaVisibility.PROTECTED);
      method.setName("addCriterionForJDBCTime"); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getDateInstance(), "value")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "property")); // $NON-NLS-1$
      method.addBodyLine("if (value == null) {"); // $NON-NLS-1$
      method.addBodyLine(
          "throw new RuntimeException(\"Value for \" + property + \" cannot be null\");"); //$NON-NLS-1$
      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine(
          "addCriterion(condition, new java.sql.Time(value.getTime()), property);"); //$NON-NLS-1$
      answer.addMethod(method);

      method = new Method();
      method.setVisibility(JavaVisibility.PROTECTED);
      method.setName("addCriterionForJDBCTime"); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
      method.addParameter(new Parameter(listOfDates, "values")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "property")); // $NON-NLS-1$
      method.addBodyLine("if (values == null || values.size() == 0) {"); // $NON-NLS-1$
      method.addBodyLine(
          "throw new RuntimeException(\"Value list for \" + property + \" cannot be null or empty\");"); //$NON-NLS-1$
      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine(
          "List<java.sql.Time> timeList = new ArrayList<java.sql.Time>();"); //$NON-NLS-1$
      method.addBodyLine("Iterator<Date> iter = values.iterator();"); // $NON-NLS-1$
      method.addBodyLine("while (iter.hasNext()) {"); // $NON-NLS-1$
      method.addBodyLine("timeList.add(new java.sql.Time(iter.next().getTime()));"); // $NON-NLS-1$
      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine("addCriterion(condition, timeList, property);"); // $NON-NLS-1$
      answer.addMethod(method);

      method = new Method();
      method.setVisibility(JavaVisibility.PROTECTED);
      method.setName("addCriterionForJDBCTime"); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "condition")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getDateInstance(), "value1")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getDateInstance(), "value2")); // $NON-NLS-1$
      method.addParameter(
          new Parameter(FullyQualifiedJavaType.getStringInstance(), "property")); // $NON-NLS-1$
      method.addBodyLine("if (value1 == null || value2 == null) {"); // $NON-NLS-1$
      method.addBodyLine(
          "throw new RuntimeException(\"Between values for \" + property + \" cannot be null\");"); //$NON-NLS-1$
      method.addBodyLine("}"); // $NON-NLS-1$
      method.addBodyLine(
          "addCriterion(condition, new java.sql.Time(value1.getTime()), new java.sql.Time(value2.getTime()), property);"); //$NON-NLS-1$
      answer.addMethod(method);
    }

    for (IntrospectedColumn introspectedColumn : introspectedTable.getNonBLOBColumns()) {
      topLevelClass.addImportedType(introspectedColumn.getFullyQualifiedJavaType());

      // here we need to add the individual methods for setting the
      // conditions for a field
      answer.addMethod(getSetNullMethod(introspectedColumn));
      answer.addMethod(getSetNotNullMethod(introspectedColumn));
      answer.addMethod(getSetEqualMethod(introspectedColumn));
      answer.addMethod(getSetNotEqualMethod(introspectedColumn));
      answer.addMethod(getSetGreaterThanMethod(introspectedColumn));
      answer.addMethod(getSetGreaterThenOrEqualMethod(introspectedColumn));
      answer.addMethod(getSetLessThanMethod(introspectedColumn));
      answer.addMethod(getSetLessThanOrEqualMethod(introspectedColumn));

      if (introspectedColumn.isJdbcCharacterColumn()) {
        answer.addMethod(getSetLikeMethod(introspectedColumn));
        answer.addMethod(getSetNotLikeMethod(introspectedColumn));
      }

      answer.addMethod(getSetInOrNotInMethod(introspectedColumn, true));
      answer.addMethod(getSetInOrNotInMethod(introspectedColumn, false));
      answer.addMethod(getSetBetweenOrNotBetweenMethod(introspectedColumn, true));
      answer.addMethod(getSetBetweenOrNotBetweenMethod(introspectedColumn, false));
    }

    return answer;
  }
 protected void addImportsForAnnotations(TopLevelClass topLevelClass, String... annotations) {
   for (String strAnnot : annotations)
     topLevelClass.addImportedType(new FullyQualifiedJavaType(IMPORT_PREFIX + strAnnot));
 }