querycondition.java

基于java的组号查询模块

//	/**
//	 * 添加等于操作的条件表达式，指定条件名称、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
//	 * 
//	 * @param condition_name
//	 * @param condition_value
//	 * @param isReplaceRepeat
//	 * @return
//	 */
//	public QueryCondition putCondition(String condition_name, double condition_value, boolean isReplaceRepeat) {
//		return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, isReplaceRepeat);
//	}
//
//	/**
//	 * 添加条件表达式，指定条件名称、条件操作、条件值，默认不覆盖有同样名的查询条件
//	 * 
//	 * @param condition_name
//	 * @param condition_op
//	 * @param condition_value
//	 * @return
//	 */
//	public QueryCondition putCondition(String condition_name, String condition_op, double condition_value) {
//		return putCondition(condition_name, condition_op, condition_value, false);
//	}
//
//	/**
//	 * 添加条件表达式，指定条件名称、条件操作、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
//	 * 
//	 * @param condition_name
//	 * @param condition_op
//	 * @param condition_value
//	 * @param isReplaceRepeat
//	 * @return
//	 */
//	public QueryCondition putCondition(String condition_name, String condition_op, double condition_value, boolean isReplaceRepeat) {
//		if (isReplaceRepeat)
//			removeCondition(condition_name); 
//
//		conditions.add(new QueryExpression(condition_name, condition_op, new Double(condition_value)));
//		return this;
//	}

/* ********************
 * 
 * 暂时屏蔽
 * 	下面的传入布尔型的方法会和
 * 	putCondition(String condition_name, Object condition_value, boolean isReplaceRepeat)冲突
 * 	为了防止出现使用错误，先屏蔽该方法
 * 
 * ********************/
	
//	/**
//	 * 添加等于操作的条件表达式，指定条件名称、条件值，默认查询操作为"="，并且不覆盖有同样名的查询条件
//	 * 
//	 * @param condition_name
//	 * @param condition_value
//	 * @return
//	 */
//	public QueryCondition putCondition(String condition_name, boolean condition_value) {
//		return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, false);
//	}
//
//	/**
//	 * 添加等于操作的条件表达式，指定条件名称、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
//	 * 
//	 * @param condition_name
//	 * @param condition_value
//	 * @param isReplaceRepeat
//	 * @return
//	 */
//	public QueryCondition putCondition(String condition_name, boolean condition_value, boolean isReplaceRepeat) {
//		return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, isReplaceRepeat);
//	}
//
//	/**
//	 * 添加条件表达式，指定条件名称、条件操作、条件值，默认不覆盖有同样名的查询条件
//	 * 
//	 * @param condition_name
//	 * @param condition_op
//	 * @param condition_value
//	 * @return
//	 */
//	public QueryCondition putCondition(String condition_name, String condition_op, boolean condition_value) {
//		return putCondition(condition_name, condition_op, condition_value, false);
//	}
//
//	/**
//	 * 添加条件表达式，指定条件名称、条件操作、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
//	 * 
//	 * @param condition_name
//	 * @param condition_op
//	 * @param condition_value
//	 * @param isReplaceRepeat
//	 * @return
//	 */
//	public QueryCondition putCondition(String condition_name, String condition_op, boolean condition_value, boolean isReplaceRepeat) {
//		if (isReplaceRepeat)
//			removeCondition(condition_name); 
//
//		conditions.add(new QueryExpression(condition_name, condition_op, new Boolean(condition_value)));
//		return this;
//	}
	
	/**
	 * 去除给定名称的条件表达式，如果有多个同名的条件表达式，则删除第一个找到的条件表达式
	 * 
	 * @param condition_name
	 */
	public void removeCondition(String condition_name) {
		QueryExpression queryExpression = getCondition(condition_name);
		if (queryExpression != null)
			conditions.remove(queryExpression);
	}
	
	/**
	 * 清除所有的查询条件
	 */
	public void clearCondition() {
		while (conditions.size() > 0)
			conditions.remove(0);
	}

	/**
	 * 检索给定表达式名称找到的第一个表达式，如果没有找到满足条件的表达式，返回null
	 * 
	 * @param condition_name
	 * @return
	 */
	public QueryExpression getCondition(String condition_name) {
		Iterator it = conditions.iterator();
		while (it.hasNext()) {
			QueryExpression queryExpression = (QueryExpression)it.next();
			if (condition_name.equals(queryExpression.getName()))
				return queryExpression;
		}
		
		return null;
	}
	
	/**
	 * 开始进行查询条件遍历
	 * 
	 */
	public void beginFindCondition() {
		itCondition = conditions.iterator();
	}
	
	/**
	 * 遍历搜索下一个查询条件，如果已经遍历完成，返回null
	 * 
	 * @return
	 */
	public QueryExpression findNextCondition() {
		if (itCondition == null)
			beginFindCondition();
		
		if (itCondition.hasNext())
			return (QueryExpression)itCondition.next();
		else
			return null;
	}

	/**
	 * @return the orders
	 */
	public List getOrders() {
		return orders;
	}

	/**
	 * @param orders the orders to set
	 */
	public void setOrders(List orders) {
		this.orders = orders;
	}
	
	/**
	 * 添加排序字段，指定排序字段和排序顺序，如果有同名的排序字段，则覆盖排序方向
	 * 
	 * @param order_name
	 * @param order_dir
	 * @return
	 */
	public QueryCondition addOrder(String order_name, String order_dir) {
		QueryOrder queryOrder = getOrder(order_name);
		
		if (!QueryOrder.DIR_ASC.equals(order_dir) && !QueryOrder.DIR_DESC.equals(order_dir)) 
			order_dir = QueryOrder.DIR_ASC;
		
		if (queryOrder != null)
			queryOrder.setDir(order_dir);
		else
			orders.add(new QueryOrder(order_name, order_dir));
		
		return this;
	}
	
	/**
	 * 添加排序字段，默认为正序排序
	 * 
	 * @param order_name
	 * @return
	 */
	public QueryCondition addOrder(String order_name) {
		return addOrder(order_name, QueryOrder.DIR_ASC);
	}
	
	/**
	 * 删除指定名称的排序字段
	 * 
	 * @param order_name
	 */
	public void removeOrder(String order_name) {
		QueryOrder queryOrder = getOrder(order_name);
		if (queryOrder != null)
			orders.remove(queryOrder);
	}
	
	/**
	 * 清除所有的排序字段
	 */
	public void clearOrder() {
		while (orders.size() > 0)
			orders.remove(0);
	}
	
	/**
	 * 返回指定名称的排序信息
	 * 
	 * @param order_name
	 * @return
	 */
	public QueryOrder getOrder(String order_name) {
		Iterator it = orders.iterator();
		while (it.hasNext()) {
			QueryOrder queryOrder = (QueryOrder)it.next();
			if (order_name.equals(queryOrder.getName()))
				return queryOrder;
		}
		
		return null;
	}
	
	/**
	 * 开始遍历排序条件
	 */
	public void beginFindOrder() {
		itOrder = orders.iterator();
	}
	
	/**
	 * 遍历下一个排序条件，如果已经遍历完成，则返回null
	 * @return
	 */
	public QueryOrder findNextOrder() {
		if (itOrder == null)
			beginFindOrder();
		
		if (itOrder.hasNext())
			return (QueryOrder)itOrder.next();
		else
			return null;
	}

	/**
	 * 返回当前查询的分页页号
	 * 
	 * @return the pageNo
	 */
	public int getPageNo() {
		return pageNo;
	}

	/**
	 * 设置当前查询的分页页号
	 * 
	 * @param pageNo the pageNo to set
	 */
	public QueryCondition setPageNo(int pageNo) {
		this.pageNo = pageNo;
		
		return this;
	}

	/**
	 * 返回当前查询的分页每页记录数
	 * 
	 * @return the pageSize
	 */
	public int getPageSize() {
		return pageSize;
	}

	/**
	 * 设置当前查询的分页每页记录数
	 * 
	 * @param pageSize the pageSize to set
	 */
	public QueryCondition setPageSize(int pageSize) {
		this.pageSize = pageSize;
		
		return this;
	}

	/**
	 * @see java.lang.Object#equals(Object)
	 */
	public boolean equals(Object object) {
		if (!(object instanceof QueryCondition)) {
			return false;
		}
		QueryCondition rhs = (QueryCondition) object;
		return new EqualsBuilder().append(
				this.selects, rhs.selects).append(this.groupbys, rhs.groupbys)
				.append(this.orders, rhs.orders).append(this.pageSize, rhs.pageSize)
				.append(this.conditions, rhs.conditions).append(this.pageNo, rhs.pageNo)
				.isEquals();
	}

	/**
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {
		return new HashCodeBuilder(-2021626145, -489366831)
				.append(this.selects)
				.append(this.conditions)
				.append(this.groupbys)
				.append(this.orders)
				.append(this.pageSize)
				.append(this.pageNo)
				.toHashCode();
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return new ToStringBuilder(this)
				.append("selects", this.selects)
				.append("conditions", this.conditions)
				.append("groupbys", this.groupbys)
				.append("orders", this.orders)
				.append("pageSize", this.pageSize)
				.append("pageNo", this.pageNo)
				.toString();
	}
}