condition
 :  logical_term ( ("or"^ | "或者"^) logical_term )*
 ;

logical_term
 : logical_factor ( ("and"^ | "并且"^) logical_factor )*
 ;

logical_factor
 : ( exp_simple compare_op exp_simple ) => (exp_simple compare_op exp_simple )
  {#logical_factor = #([COMPARE_OP, "comp_op"], #logical_factor);}
 |  ( exp_simple ( "in" | "在于" ) ) => exp_simple ( "in" | "在于" ) exp_set
  { #logical_factor = #([LOGICAL_CONTAIN, "logic_contain"], #logical_factor); }
 | ( exp_simple ( "not in" | "不在于" ) ) => exp_simple ( "not in" | "不在于" ) exp_set
  { #logical_factor = #([LOGICAL_CONTAIN, "logic_contain"], #logical_factor); }
 |  ( exp_simple ( "like" | "包含" ) ) => exp_simple ("like" | "包含" ) where_expression ( "escape" QUOTED_STRING )?
  { #logical_factor = #([LOGICAL_LIKE, "logic_like"], #logical_factor); }
 |  ( exp_simple ( "not like" | "不包含" ) ) => exp_simple ("not like" | "不包含" ) where_expression ( "escape" QUOTED_STRING )?
  { #logical_factor = #([LOGICAL_LIKE, "logic_like"], #logical_factor); }
 |  ( exp_simple ( "between"| "范围" ) ) => exp_simple ( "between" | "范围" ) exp_simple exp_simple
  { #logical_factor = #([LOGICAL_BETWEEN, "logic_between"], #logical_factor); }
 |  ( exp_simple ( "not between"| "不在范围" ) ) => exp_simple ( "not between" | "不在范围" ) exp_simple exp_simple
  { #logical_factor = #([LOGICAL_BETWEEN, "logic_between"], #logical_factor); }
 |  ( exp_simple ( "is null" | "为空" ) ) => exp_simple ( "is null" | "为空" )
  { #logical_factor = #([LOGICAL_NULL, "logic_null"], #logical_factor); }
 |  ( exp_simple ( "is not null" | "非空" ) ) => exp_simple ( "is not null" | "非空" )
  { #logical_factor = #([LOGICAL_NULL, "logic_null"], #logical_factor); }
 |  ( quantified_factor ) => quantified_factor
  { #logical_factor = #([LOGICAL_EXISTS, "logic_exists"], #logical_factor); }
 |  ( ( "not" | "非" ) condition ) => ( "not" | "非" ) condition
  { #logical_factor = #([COND_NOT, "cond_not"], #logical_factor); }
 |  ( LPAREN condition RPAREN )
  { #logical_factor = #([COND_PAREN, "cond_paren"], #logical_factor); }
    ;

quantified_factor
 : ( exp_simple compare_op ( "all" | "any" )? subquery ) => exp_simple compare_op ( "all" | "any" )? subquery
    |  ( ( "not" )? "exists" subquery ) => ( "not" )? "exists" subquery
    |  subquery
    ;

exp_simple
 :  where_expression
 ;

where_expression
 :  term ( ( PLUS^ | MINUS^ | "加"^ | "减"^) term )*
    ;

term
 :  factor ( ( MUL^ | DIVIDE^ | "乘"^ | "除"^) factor )*
    ;
 
multiply
 : MUL | "乘"
        { #multiply = #([MULTIPLY, "multiply"], #multiply); }
    ;

factor
 : ( sql_literal ) => sql_literal
 | ( ( PLUS | MINUS ) where_expression ) => ( PLUS | MINUS ) where_expression
 | ( function_name ( LPAREN where_expression ( COMMA where_expression )* RPAREN ) ) => function_name ( LPAREN where_expression ( COMMA where_expression )* RPAREN )
  { #factor = #([NORMAL_FUNCTION, "normal_function"], #factor); }
 |  ( aggregate_func_name LPAREN ( STAR | "all" | "distinct" )? (where_expression)? RPAREN ) => aggregate_func_name LPAREN ( STAR | "all" | "distinct" )? (where_expression)? RPAREN
        { #factor = #([GROUP_FUNCTION, "group_function"], #factor); }
 | ( LPAREN where_expression RPAREN ) => LPAREN where_expression RPAREN
  { #factor = #([EXPRESSION_PAREN, "expression_paren"], #factor); }
 ;

sql_literal
 : constant
 | field_name
 ;

where_expression_list
 : LPAREN where_expression ( COMMA where_expression )+ RPAREN
 ;

exp_set
 :  LPAREN constexpset RPAREN
 {#exp_set = #([SUBCONTAIN_OP, "subcontain_op"], #exp_set);}
// | subquery
 ;

constexpset
 : constant (COMMA^ constant)*
// {#constexpset = #([SUBCONTAIN_CONTENT, "subcontain_content"], #constexpset);}
 ;
/*==================================================================//
//                                                                 //
//      Where Condition End                                        //
//                                                                 //
//==================================================================*/

  /**
   * 取得循环语句类型（1为表变量，2为条件变量）
   * @return String 循环语句类型
   */
  public String getCircleType() {
    return circleType;
  }
 
  /**
   * 设置取得循环语句类型
   * @param circleType （1为表变量，2为条件变量）
   */
  public void setCircleType(String circleType) {
    this.circleType = circleType;
  }
 
2、QueryModel的parseQuery()方法增加对circleType的设置：
   //如果存在条件变量参数，格式为：{机构变量}
   QueryModel[] _paramModelArr = model.getModelsFromAllChildrenByClass(ParamModel.class);
   if (_paramModelArr.length > 0)
      model.setCircleType(((ParamModel) _paramModelArr[0]).getCircleType());

3、Translator:
  addDbTable  将循环语句类型设置到QueryModel(表变量)
  addDbField  将循环语句类型设置到QueryModel(条件变量)
  getXmlString() 将circleType增加到ch_query_string的属性值中
  loadModelFromXML(...) 增加从XML中将circleType设置到QueryModel