Why Using 1=1 in SQL Is a Bad Habit and How to Write Cleaner Queries

Why 1=1 appears in legacy Java/MyBatis code

In many older Java projects that use MyBatis, developers often prepend a constant true condition ( 1=1) to the WHERE clause. This avoids having to decide whether the first real condition needs an AND prefix, because every subsequent condition is written as AND ….

Potential performance impact

Most modern query optimizers recognise that 1=1 is always true and remove it during optimisation. However, not all databases guarantee this removal. In some cases the optimizer may retain the predicate, causing an unnecessary full‑table scan and extra CPU cycles.

Code‑quality concerns

Clarity: The always‑true predicate can confuse readers of complex SQL.

Consistency: It violates clean‑code guidelines that discourage meaningless conditions.

Portability: Some databases do not optimise the predicate away, leading to performance regressions when the same SQL is run on a different engine.

Recommended alternatives

MyBatis provides dynamic SQL tags that automatically handle the leading logical operator. The two most common tags are <if> for conditional inclusion and <where> for automatic removal of the leading AND or OR.

SELECT * FROM user
<where>
    <if test="username != null and username != ''">
        AND username = #{username}
    </if>
    <if test="age > 0">
        AND age = #{age}
    </if>
    <!-- additional conditions can be added similarly -->
</where>

Full MyBatis mapper example:

<!-- MyBatis mapper snippet -->
<select id="selectUsersByConditions" parameterType="map" resultType="com.example.User">
    SELECT * FROM user
    <where>
        <if test="username != null and username != ''">
            AND username = #{username}
        </if>
        <if test="age > 0">
            AND age = #{age}
        </if>
        <!-- more conditions … -->
    </where>
</select>

When using an ORM such as Entity Framework, the same effect can be achieved by building the query conditionally in code; the framework adds the appropriate logical operators and never requires a dummy 1=1 clause.

var query = context.User.AsQueryable();
if (!string.IsNullOrEmpty(username))
{
    query = query.Where(u => u.UserName.Contains(username));
}
if (age > 0)
{
    query = query.Where(u => u.Age == age);
}
var users = query.ToList();

Conclusion

Using a constant true predicate like 1=1 may look harmless, but it introduces unnecessary noise, can hinder optimisation on some databases, and reduces code readability. Leveraging MyBatis dynamic tags ( <if>, <where>) or ORM‑level conditional query building yields cleaner, more maintainable, and potentially faster SQL generation.