# GeoLibre Attribute Table Query Operations: A Complete Guide to Filtering and Expressions

> Discover GeoLibre attribute table query operations including logical comparison pattern spatial and arithmetic expressions. Filter your data efficiently with this complete guide.

- Repository: [Open Geospatial Solutions/GeoLibre](https://github.com/opengeos/GeoLibre)
- Tags: how-to-guide
- Published: 2026-07-31

---

**The GeoLibre attribute table supports logical, comparison, pattern-matching, spatial, and arithmetic query operations parsed by the core expression engine in `@geolibre/core` and executed via DuckDB-WASM or client-side processing.**

The **GeoLibre attribute table**, part of the open-source `opengeos/GeoLibre` repository, provides a robust interface for inspecting vector feature properties and raster attribute data. Users can filter, sort, and edit attributes using an expressive query language powered by the `@geolibre/core` expression engine. These **GeoLibre attribute table query operations** range from simple value comparisons to advanced spatial predicates, executing either client-side for editable GeoJSON layers or through DuckDB-WASM for complex analytical queries.

## Supported Query Operation Categories

GeoLibre implements a comprehensive expression language that supports eight major categories of operations.

### Logical Operators

Combine multiple filter conditions using boolean logic:

- `AND` — Returns records where both conditions are true
- `OR` — Returns records where either condition is true
- `NOT` — Negates a condition

### Comparison Operators

Evaluate equality and ordering for numeric and string fields:

- `=`, `!=` — Equality and inequality
- `>`, `<`, `>=`, `<=` — Greater than, less than, and inclusive variants

### Set Membership

Test whether values exist within defined collections:

- `IN (value1, value2)` — Field matches any item in the list
- `NOT IN (...)` — Field matches no items in the list

### Pattern Matching

Perform case-insensitive substring and pattern searches:

- `LIKE '%text%'` — SQL-style pattern matching with wildcards
- `STARTS_WITH`, `ENDS_WITH` — Prefix and suffix matching
- `CONTAINS` — Substring search

### Null Handling

Detect missing or undefined values:

- `IS NULL` — Field has no value
- `IS NOT NULL` — Field has any value

### Arithmetic Operations

Compute values within expressions:

- `+`, `-`, `*`, `/`, `%` — Standard mathematical operators for numeric fields

### Spatial Predicates

Execute geometric relationships when layers contain geometry data (forwarded to DuckDB-WASM spatial extensions):

- `INTERSECTS(geometry)` — Features that cross or overlap
- `WITHIN(geometry)` — Features completely inside bounds
- `CONTAINS(geometry)` — Features that enclose the specified geometry

### Utility Functions

Transform and clean attribute data:

- `UPPER()`, `LOWER()` — Case conversion
- `TRIM()` — Remove whitespace
- `COALESCE()` — Return first non-null value
- `ROUND()`, `ABS()` — Numeric rounding and absolute value

## How the Query Engine Works

The attribute table leverages the core expression parser located in [`packages/core/src/expressions.ts`](https://github.com/opengeos/GeoLibre/blob/main/packages/core/src/expressions.ts) to tokenize and validate query strings. According to the `opengeos/GeoLibre` source code, the system processes queries through two distinct execution paths.

**Client-side execution** handles editable GeoJSON layers directly within the browser, applying filters to the in-memory feature collection.

**DuckDB-WASM execution** routes complex analytical queries, including spatial operations, through the WebAssembly-based DuckDB engine defined in [`packages/processing/src/wasm-convert.ts`](https://github.com/opengeos/GeoLibre/blob/main/packages/processing/src/wasm-convert.ts). Spatial predicates like `ST_Intersects` are translated into DuckDB spatial functions for high-performance geoprocessing.

The UI synchronizes selections between the table and map canvas via [`packages/map/src/MapCanvas.tsx`](https://github.com/opengeos/GeoLibre/blob/main/packages/map/src/MapCanvas.tsx), ensuring filtered results highlight corresponding map features immediately.

## Practical Implementation Examples

The following TypeScript React examples demonstrate how to apply query operations when instantiating the AttributeTable component in `apps/geolibre-desktop`.

### Basic Numeric Filter

Display only features where the population exceeds 10,000:

```tsx
<AttributeTable
  layer={myVectorLayer}
  filter="population > 10000"
/>

```

### Text Pattern Matching

Search for parks containing "National" in their name:

```tsx
<AttributeTable
  layer={myVectorLayer}
  filter="name LIKE '%National%'"
/>

```

### Complex Logical Expressions

Combine multiple conditions using parentheses and boolean operators:

```tsx
<AttributeTable
  layer={myVectorLayer}
  filter="(type = 'road' OR type = 'rail') AND length >= 500"
/>

```

### Spatial Queries with DuckDB-WASM

Filter features intersecting a user-drawn polygon:

```tsx
<AttributeTable
  layer={myVectorLayer}
  filter="ST_Intersects(geom, $myPolygon)"
/>

```

In the desktop application, users construct these queries interactively through the **filter row** at the top of the attribute table, selecting fields from dropdowns populated via [`apps/geolibre-desktop/src/lib/expression-inputs.ts`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src/lib/expression-inputs.ts).

## Key Source Files

Understanding the query operation implementation requires examining these specific modules:

- [`packages/core/src/expressions.ts`](https://github.com/opengeos/GeoLibre/blob/main/packages/core/src/expressions.ts) — Core parser that tokenizes query strings and validates operator syntax
- [`apps/geolibre-desktop/src/components/panels/AttributeTable.tsx`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src/components/panels/AttributeTable.tsx) — Main UI component that builds and applies filter expressions
- [`apps/geolibre-desktop/src/lib/expression-inputs.ts`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src/lib/expression-inputs.ts) — Helper utilities for retrieving attribute names and data types
- [`packages/map/src/MapCanvas.tsx`](https://github.com/opengeos/GeoLibre/blob/main/packages/map/src/MapCanvas.tsx) — Maplibre integration that syncs table filters with layer rendering
- [`packages/processing/src/wasm-convert.ts`](https://github.com/opengeos/GeoLibre/blob/main/packages/processing/src/wasm-convert.ts) — DuckDB-WASM bridge for executing spatial and analytical SQL functions

## Summary

- GeoLibre supports **eight categories of query operations**: logical, comparison, set membership, pattern matching, null checks, arithmetic, spatial, and utility functions.
- The **expression parser** in [`packages/core/src/expressions.ts`](https://github.com/opengeos/GeoLibre/blob/main/packages/core/src/expressions.ts) validates all query syntax before execution.
- **DuckDB-WASM** powers spatial predicates and complex analytics, while simple filters run client-side for GeoJSON layers.
- Users interact with queries through a **filter row UI** that constructs expression strings automatically.
- Query results synchronize bidirectionally between the attribute table and the map canvas via [`MapCanvas.tsx`](https://github.com/opengeos/GeoLibre/blob/main/MapCanvas.tsx).

## Frequently Asked Questions

### What expression syntax does GeoLibre use for attribute queries?

GeoLibre uses a SQL-like expression syntax parsed by its core expression engine. The syntax supports standard operators including `AND`, `OR`, `LIKE`, `IN`, and spatial functions such as `ST_Intersects`, making it familiar to users of traditional GIS and database systems.

### Can I perform spatial queries directly in the attribute table?

Yes, spatial queries are supported when working with layers that contain geometry data. These operations leverage DuckDB-WASM spatial extensions and use predicates like `INTERSECTS`, `WITHIN`, and `CONTAINS`. However, spatial filtering requires the DuckDB-WASM backend rather than client-side processing.

### How does GeoLibre handle large datasets when filtering?

For large datasets, GeoLibre offloads query execution to DuckDB-WASM ([`packages/processing/src/wasm-convert.ts`](https://github.com/opengeos/GeoLibre/blob/main/packages/processing/src/wasm-convert.ts)), which provides high-performance analytical SQL capabilities running in WebAssembly. Smaller editable GeoJSON layers are filtered client-side in memory for responsive editing.

### Where is the query logic defined in the source code?

The query parsing logic resides in [`packages/core/src/expressions.ts`](https://github.com/opengeos/GeoLibre/blob/main/packages/core/src/expressions.ts), while the UI implementation is found in [`apps/geolibre-desktop/src/components/panels/AttributeTable.tsx`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src/components/panels/AttributeTable.tsx). The map synchronization logic connecting table filters to visual selections is implemented in [`packages/map/src/MapCanvas.tsx`](https://github.com/opengeos/GeoLibre/blob/main/packages/map/src/MapCanvas.tsx).