How do I filter rows that fall within an inclusive numeric range in SQLite?

Use BETWEEN for a compact inclusive range condition. Assuming your table is named products and the numeric column is named price, write:

SELECT name, price
FROM products
WHERE price BETWEEN 10 AND 20
ORDER BY price;

In SQLite, price BETWEEN 10 AND 20 is logically equivalent to price >= 10 AND price <= 20, so both endpoints are included. [S1] The names and sample values here are illustrative; replace them with your actual table and column names. ORDER BY price is included to make the example output easy to read.

Assume the illustrative products table contains these rows:

name       price
Notebook       8
Mug            10
Pen set        15
Desk lamp      20
Backpack       22

With the BETWEEN query, the result is:

name       price
Mug            10
Pen set        15
Desk lamp      20

The equivalent version using two comparisons is:

SELECT name, price
FROM products
WHERE price >= 10 AND price <= 20
ORDER BY price;

It selects the same three rows: 10 meets the lower boundary, 20 meets the upper boundary, and 15 is between them. The row priced 8 fails the lower comparison, while 22 fails the upper comparison. SQLite defines BETWEEN as equivalent to those inclusive comparisons. [S1]

Either form works for this inclusive range. BETWEEN 10 AND 20 is concise and makes the intended range easy to spot. The two-comparison form spells out each boundary, which can be useful if you are building a more involved condition or want to inspect the lower and upper checks separately.

To keep the endpoints included, use BETWEEN lower_value AND upper_value, or write both >= lower_value and <= upper_value. Do not replace either comparison with a strict operator: > 10 excludes a value equal to 10, and < 20 excludes a value equal to 20. Those observations follow directly from the comparison symbols; SQLite’s documented equivalence confirms the inclusive version. [S1]

For example, if your intended bounds are 10 and 20, check that the condition is price >= 10 AND price <= 20, not price > 10 AND price < 20.

Run the query and compare its returned prices with the values you expect to fall within your chosen bounds. For the illustration, the expected prices are 10, 15, and 20; 8 and 22 should not appear. [S1]

If the result differs from your expectation, check that the query filters the intended column and uses the intended numeric bounds. This example demonstrates SQLite’s inclusive range behavior for the illustrated values; it does not establish anything about your particular table’s schema or data.