<arg>"mimetype"</arg>
			<arg>"application/vnd.ms-excel.sheet.3"</arg>
		</postConstruct>
		<postConstruct name="addCondition">
			<arg>"mimetype"</arg>
			<arg>"application/vnd.ms-excel.sheet.4"</arg>
		</postConstruct>
		<postConstruct name="addCondition">
			<arg>"mimetype"</arg>
			<arg>"application/vnd.ms-excel.workspace.3"</arg>
		</postConstruct>
		<postConstruct name="addCondition">

    protected int maxRedirectCount = 10;

    protected Boolean available = null;

    public void register() {
        ComponentUtil.getThumbnailManager().add(this);
    }

    public void addCondition(final String key, final String regex) {
        final String value = conditionMap.get(key);
        if (StringUtil.isBlank(value)) {
            conditionMap.put(key, regex);
        } else {

func (where Where) Name() string {
	return "WHERE"
}

// Build build where clause
func (where Where) Build(builder Builder) {
	if len(where.Exprs) == 1 {
		if andCondition, ok := where.Exprs[0].(AndConditions); ok {
			where.Exprs = andCondition.Exprs
		}
	}

	// Switch position if the first query expression is a single Or condition
	for idx, expr := range where.Exprs {

	Expression *Expression `parser:"@@"`
	As         string      `parser:"[ \"AS\" @Ident | \"AS\" @LitString ]"`
}

// Grammar for Expression
//
// Expression          → AndCondition ("OR" AndCondition)*
// AndCondition        → Condition ("AND" Condition)*
// Condition           → "NOT" Condition | ConditionExpression
// ConditionExpression → ValueExpression ("=" | "<>" | "<=" | ">=" | "<" | ">") ValueExpression

	for _, ex := range e.Elements {
		err := ex.aggregateRow(r, tableAlias)
		if err != nil {
			return err
		}
	}
	return nil
}

func (e *AndCondition) aggregateRow(r Record, tableAlias string) error {
	for _, ex := range e.Condition {
		err := ex.aggregateRow(r, tableAlias)
		if err != nil {
			return err
		}
	}
	return nil
}

	return e.Expression.analyze(s)
}

func (e *Expression) analyze(s *Select) (result qProp) {
	for _, ac := range e.And {
		result.combine(ac.analyze(s))
	}
	return
}

func (e *AndCondition) analyze(s *Select) (result qProp) {
	for _, ac := range e.Condition {
		result.combine(ac.analyze(s))
	}
	return
}

func (e *Condition) analyze(s *Select) (result qProp) {
	if e.Operand != nil {

		}
		b, ok := res.ToBool()
		if !ok {
			return nil, errExpectedBool
		}
		if b {
			return FromBool(true), nil
		}
		result = result || b
	}
	return FromBool(result), nil
}

func (e *AndCondition) evalNode(r Record, tableAlias string) (*Value, error) {
	if len(e.Condition) == 1 {
		// In this case, result does not have to be boolean
		return e.Condition[0].evalNode(r, tableAlias)
	}