no warehouse required
Query faster.
Skip the warehouse.
AirMettle Select prepares data in object storage once, then runs parallel SQL queries where the data already lives—built for a faster path than conventional serverless object-storage analytics, without loading a separate data warehouse first.
Product Highlights
- Best forFast, selective SQL over operational data already in object storage.
- Direct formatsQuery CSV, JSON, JSON Lines, and GZIP-compressed inputs in place.
- Data stays yoursSource objects and acceleration metadata remain in customer-controlled storage.
A faster query path leaves out the warehouse detour.
Mainstream stacks copy, transform, load, and rescan data before returning an answer. AirMettle Select prepares compact metadata once, analyzes the source data in place, and streams only the selected output.
Stage first. Query later.
Prepare once. Query directly.
High performance without another data platform.
A faster query engine, without the warehouse overhead.
Query more of what is already in object storage.
Query CSV, JSON, JSON Lines, and GZIP-compressed inputs today. Contact us for early access to Parquet, HDF5, and NetCDF4.
{{ f.title }}
{{ f.description }}
Confirmation of financial support from the Department of Energy and NOAA does not imply a formal endorsement of the products by these agencies.
Background metadata generation.
For subscribed buckets, metadata is prepared automatically in the background as data arrives from your existing processes—no manual preparation step required.
A selection layer between stored objects and useful answers.
Keep source data in object storage. AirMettle Select creates compact sidecar metadata in the same customer-controlled storage boundary, analyzes the original objects in place, and returns only the records your application needs.
From setup to your first query.
Follow the maintained guides for connecting resources, preparing objects, and querying with AirMettle Select.
Run your first query in five minutes.
AirMettle Select lets you run SQL queries directly against CSV, JSON, and JSON Lines objects in object storage. This quickstart walks through a typical workflow and shows how to get started quickly.
First-time workspace setup
- Install the Python package and utilities.
- Save your subscription credentials.
- Link your storage account using the API.
Development workflow
- Before querying a blob for the first time, call the API to prepare metadata for fast queries.
- Run a query on the blob using the Python client.
1. Pick a blob to query
Pick a CSV or JSON blob in your object storage account that you want to query. You need the object URL plus the account name and key.
2. Install the Python package
Use the Python client in this quickstart and install httpx for API calls.
pip install pyamselect httpx
3. Save your credentials
Add your subscription ID, API key, and storage account key as environment variables so credentials stay out of source code.
export AIRMETTLE_SUBSCRIPTION_ID="YOUR_SUBSCRIPTION_ID" export AIRMETTLE_API_KEY="YOUR_API_KEY" export STORAGE_ACCOUNT_KEY="YOUR_STORAGE_ACCOUNT_KEY"
$env:AIRMETTLE_SUBSCRIPTION_ID="YOUR_SUBSCRIPTION_ID" $env:AIRMETTLE_API_KEY="YOUR_API_KEY" $env:STORAGE_ACCOUNT_KEY="YOUR_STORAGE_ACCOUNT_KEY"
set AIRMETTLE_SUBSCRIPTION_ID=YOUR_SUBSCRIPTION_ID set AIRMETTLE_API_KEY=YOUR_API_KEY set STORAGE_ACCOUNT_KEY=YOUR_STORAGE_ACCOUNT_KEY
4. Link your storage account using the API
Link your object storage account to AirMettle Select. This is a one-time step per account.
import os
import httpx
# Include your subscription credentials in the request headers
headers = {
"x-subscription-id": os.getenv("AIRMETTLE_SUBSCRIPTION_ID"),
"x-api-key": os.getenv("AIRMETTLE_API_KEY"),
}
# Create the request body with the storage account name and key
request = {
"storage_account": "yourstorageaccount",
"account_key": os.getenv("STORAGE_ACCOUNT_KEY")
}
response = httpx.post("https://api.airmettle.com/api/v1/buckets", json=request, headers=headers)
print(response.status_code, response.text)
A 201 Created response means the account was linked successfully.
5. Create metadata for the blob using the API
Before querying a blob, AirMettle Select generates a small sidecar metadata file. These sidecars live in a hidden directory alongside your data and enable parallel high-performance reads.
You can generate a sidecar on demand. The original blob is never modified, and you can delete and regenerate the sidecar at any time.
import os
import httpx
# Specify the blob URL and your subscription credentials in the request body
request = {
"subscription_id": os.getenv("AIRMETTLE_SUBSCRIPTION_ID"),
"api_key": os.getenv("AIRMETTLE_API_KEY"),
"blob_url": "https://yourstore.blob.core.windows.net/container/yourblob.csv",
"account_key": os.getenv("STORAGE_ACCOUNT_KEY")
}
response = httpx.post("https://api.airmettle.com/v1/prepare", json=request)
print(response.status_code, response.text)
A 200 OK response means the metadata object is ready and queryable. A 202 Accepted response means generation is asynchronous and includes a status_url for polling.
ready means the sidecar is available.
pending means generation is still in progress.
failed means metadata generation failed; review error details in the response body.
6. Run a query
In step 5, you prepared a blob using its full blob_url. In this step, identify the same blob by storage_account, container, and blob. The response is a stream of selected rows in the requested format.
import os
from pyamselect import AMSelectClient, SelectRequest, CSVInputOptions, CSVOutputOptions
# Specify which blob to query, the SQL, and input/output options
request = SelectRequest(
subscription_id=os.getenv("AIRMETTLE_SUBSCRIPTION_ID"),
api_key=os.getenv("AIRMETTLE_API_KEY"),
storage_account="yourstorageaccount",
container="yourcontainer",
blob="yourblob.csv",
expression="SELECT * FROM s3object", # Your SQL query
input_options=CSVInputOptions(csv_header_config="use",csv_field_delimiter=","), # input as CSV
output_options=CSVOutputOptions(), # output as CSV
)
# Create the client to connect to AirMettle Select
with AMSelectClient("api.airmettle.com/query", 8443) as client:
# Run the query and collect the results as a string
result = client.select_to_string(request)
print(result)
# Alternatively, write results directly to a file
# client.select_to_file(request, "output.csv")
# Or write results to a binary stream, such as a BytesIO object
# client.select_to_stream(request, stream)
Start by linking one storage account, prepare metadata for a few sample blobs, and run your first query.
File formats for AirMettle Select.
AirMettle Select runs SQL directly against CSV, JSON, and JSON Lines objects, including GZIP-compressed inputs. Contact us to evaluate Parquet and scientific formats through early access.
{{ f.description }}
Choose how data is parsed and returned.
When creating a request, set input options for parsing and output options for the stream format returned to your application.
- CSV input options include header handling and delimiter controls.
- Equivalent JSON options apply to JSON and NDJSON objects.
- CSV output options return selected rows in CSV stream form.
from pyamselect import SelectRequest, CSVInputOptions, CSVOutputOptions
request = SelectRequest(
...
expression="SELECT * FROM s3object",
input_options=CSVInputOptions(
csv_header_config="use",
csv_field_delimiter=","
),
output_options=CSVOutputOptions(),
)
Same three-step path for every supported format.
- Link the storage account once.
- Call prepare on the blob URL to generate sidecar metadata.
- Issue the SQL query with storage account, container, and blob.
Familiar SQL support for object storage queries.
AirMettle Select runs familiar SQL against CSV and JSON objects in object storage. Built on the same SQL surface as Amazon S3 Select, it provides a fast way to filter, project, and aggregate data in place.
Sidecar metadata is generated once per blob so subsequent queries run in parallel and return results quickly.
Aggregate functions ignore MISSING values and return a single summary row.
AirMettle Select implements a focused SQL subset optimized for object storage. The core statement structure is shown below. Currently, explicit JOINs are not supported.
SELECT [projections] FROM [relation] WHERE [condition] LIMIT [number]
Project specific columns, expressions, or function results and use aliases with AS.
SELECT column1, column2 SELECT *
Query a single object relation.
FROM S3Object
Filter rows with boolean expressions.
WHERE amount > 100 WHERE status = 'active' AND region IS NOT MISSING WHERE regexp_contains(email, '@company\\.com')
Cap returned records for sampling and preview.
LIMIT 100
Reference CSV columns by position (_1, _2, and so on) or by header name when headers are present. Header names are case-insensitive unless wrapped in double quotes.
SELECT _1, _3 FROM S3Object WHERE _2 > 50 SELECT email FROM S3Object WHERE status = 'active'
Use dot notation for nested fields and zero-based indexes for arrays. Start from S3Object[*] when JSON is treated as an array of root values.
SELECT s.projects[0].project_name FROM S3Object s SELECT s."CAST", s."Name" FROM S3Object s
Four use cases.
One direct data path.
Start with the storage and query benefits of compressed logs, then see that same direct data path applied to operational analytics, standardized performance, and Microsoft Fabric.
Investigate recent events without loading a warehouse.
GH Archive publishes GitHub activity as native hourly GZIP-compressed JSON Lines objects. This public example compares a newly arrived one-hour object with a six-hour operational window.
Prepare each object once, then query it in place—without a conversion pipeline, a warehouse load, or a query cluster kept warm for sporadic investigations.
{{ operationalWindowTitle }}
{{ operationalWindowDescription }}
The same ten operational checks run against one native object or six consecutive hourly objects.
View SQL
{{ q.sql }}Review exact public source files
AirMettle Select and serverless reference timings were measured on these exact public files using equivalent queries. Preparation is excluded from query runtime.
AirMettle Select on ClickBench.
See the measured advantage on CSV and JSON side by side. Both comparisons use the same 42 valid ClickBench queries and aligned serverless-reference results.
ClickBench results are on the way.
AirMettle Select and serverless reference measurements will be published side by side with the workload and test details.
Data sizes are calculated from the benchmark workbook's recorded dataset sizes and proportions. Each panel compares aligned AirMettle Select and mainstream serverless object-query results for the same valid ClickBench queries.
Maximize Performance. Minimal metadata overhead.
Keep logs compressed to save on both storage AND query costs.
Including metadata (kept in your buckets), total cost is typically 75% to 90%+ cheaper with GZIP than using raw data.
Run low-latency queries on existing GZIP-compressed CSV and JSON logs—without converting them to Parquet. Measured results on real log datasets show that GZIP query response times are competitive with those on the corresponding uncompressed originals.
Bars compare complete prepared footprints. Storage savings use GZIP object plus Select metadata versus the corresponding original Raw object. Values were measured on the linked public datasets.
Faster Response Time,
Lower cost for storage AND queries
{{ compressionViewDescription }}
View SQL
{{ q.sql }}
{{ compressionViewMethodology }}
Prepare once.
Typically no extra charge.
Each source object is prepared only once.
Filter first.
Let Fabric do more with less.
Use AirMettle Select as a query step inside Fabric pipelines and notebooks. It filters large source objects in place and returns only the selected rows, so Fabric can transform, enrich, model, and report on a much smaller input.
Keep the archive. Bring only the incident slice into Fabric.
An operations team keeps compressed audit logs in object storage. A Fabric pipeline calls AirMettle Select for the high-risk changes in an investigation window. Only that focused result enters Fabric for enrichment, modeling, or reporting; the complete archive stays in customer storage.
See how AirMettle Select performs on your data.
Designed around the data boundary you already trust.
Keep source data in object storage and limit each query to the storage scope your application is allowed to use.
{{ s.t }}
{{ s.d }}
Questions, answered.
The essentials for evaluating AirMettle Select, from supported data to deployment and pricing.