<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">

        generator = new TestThumbnailGenerator();

        // Test adding single condition
        generator.addCondition("field1", "value1");

        // Test adding multiple conditions for same field
        generator.addCondition("field1", "value2");

        // Test adding conditions for different fields
        generator.addCondition("field2", "pattern.*");

        // Verify conditions can be added without errors

    }

    /**
     * Adds a condition for thumbnail generation.
     * @param key The condition key.
     * @param regex The regex pattern for the condition.
     */
    public void addCondition(final String key, final String regex) {
        final String value = conditionMap.get(key);
        if (StringUtil.isBlank(value)) {
            conditionMap.put(key, regex);
        } else {

        emptyGenerator = new EmptyGenerator();

        // Test adding conditions - this should work without container
        emptyGenerator.addCondition("field1", "pattern1");
        emptyGenerator.addCondition("field1", "pattern2");
        emptyGenerator.addCondition("field2", "pattern.*");

        // We can't test isTarget properly without container,
        // but we can verify conditions are added

	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

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 {

	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 result
}

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

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)
	}