Will JavaScript type annotations kill TypeScript?
The creators of Svelte and Turbo 8 both dropped TS recently saying that "it's not worth it".
Yes: If JavaScript gets type annotations then there's no reason for TypeScript to exist.
No: TypeScript remains the best language for structuring large enterprise applications.
TBD: The existing user base and its corpensource owner means that TypeScript isn’t likely to reach EOL without a putting up a fight.
I hope they both die. I mean, if you really need strong types in the browser then you could leverage WASM and use a real programming language.
I don’t know and I don’t care.
Data / Edge Computing

How to Optimize Queries for Time Series Data

With the right query optimization techniques, organizations can extract valuable insights from their time-series data more efficiently and accurately. Here are some strategies and tips.
Apr 27th, 2023 12:00pm by
Featued image for: How to Optimize Queries for Time Series Data
Image by Emily Morter from Unsplash. 

In the current data-driven business landscape, organizations are heavily dependent on the time series data they collect and the stories it can tell them about what customers want — and are likely to want in the future.

With the right query optimization techniques, organizations can extract valuable insights from their time-series data faster and more efficiently, gaining a competitive edge in their respective markets.

Without those techniques, data queries will be inefficient, data analysis will be time-consuming and inaccurate, and companies will be more likely to fall behind their competitors.

As time-series data grows, the number of queries needed to access it also increases. Optimizing queries involves streamlining the process of accessing and filtering data, as well as reducing the computational resources required to process and analyze large volumes of data. This results in faster data processing, improved data accuracy, and reduced costs associated with data storage and retrieval.

In this article, we’ll share some tips for optimizing time series data queries.

Understanding Time Series Data

Time series data is a collection of data points taken at regular intervals over time. It has a temporal dimension, which means that time is an essential component of the data. This data is collected and used in various industries, such as finance, healthcare, meteorology, and manufacturing.

This data is often high-dimensional, time-stamped, and requires efficient storage and retrieval. Query optimization is crucial to ensure fast and accurate analysis.

The characteristics of time series data can be used to develop models that can capture the patterns in the data and make predictions. Time series models typically use historical data to predict future trends, and they can be used for forecasting, anomaly detection and signal processing.

Query Optimization Techniques

Here are some overall techniques for creating better queries.

Efficient Filtering

Efficient filtering can help reduce the amount of data that needs to be scanned and improve query performance.

One approach to optimizing filtering queries is to use indexing. Indexing by timestamp can improve query performance by allowing the database to quickly locate data within a specific time range. Indexing by tag can similarly improve performance when querying data based on specific metadata associated with the data.

Timestamp indexing is useful when working with data that is primarily queried by time, while tag indexing is helpful for filtering data based on specific attributes, such as sensor location or measurement type.

Query languages are also an essential factor in optimizing time-series data queries. SQL-based query languages like TimescaleDB and PostgreSQL are widely used in relational databases and have been extended to work with time series data.

Non-SQL query languages like InfluxDB have been designed specifically for working with time-series data and offer specialized features like downsampling and rollups.

When optimizing queries, choosing the right filters is also critical, as it will help reduce the amount of data that needs to be scanned. Minimizing the use of regular expressions and optimizing the use of comparison operators can also help improve query performance.


Aggregation involves reducing the amount of data that needs to be processed by combining multiple data points into a single, summary value.

One approach to aggregation is time-based aggregation, which involves grouping data into time intervals such as seconds, minutes, hours, or days. Choosing the right time interval can have a significant impact on query performance and accuracy. For example, choosing too large of an interval may result in a loss of granularity, while choosing too small of an interval may result in unnecessary processing overhead.

Another approach to aggregation is granularity and grouping, which involves grouping data based on common characteristics such as tags or metadata. Choosing the right granularity ensures that the data is accurately represented while also minimizing the amount of data that needs to be processed. Grouping data by tags can also help to identify patterns and trends within the data.

Another technique for optimizing queries, pre-aggregation involves performing aggregation at write time or query time to reduce the amount of data that needs to be processed. This can be useful for data that requires frequent querying or for data that is frequently updated.

Sampling and Compression

Sampling and compression can be used to reduce the amount of data that needs to be stored and queried, thereby improving query performance.

Downsampling is a common technique used to reduce the size of time series data by aggregating it into smaller, more manageable chunks. This can be done by taking a random sample of the data or by aggregating data points over a specific time interval.

The challenge with downsampling is to choose the right sampling rate, which can depend on the granularity of the data and the desired query performance.

Time series compression is another technique used to reduce the storage size of time series data while retaining as much of the original information as possible. Compression algorithms typically work by identifying patterns in the data and replacing them with a smaller representation. Some popular time series compression algorithms include delta encoding, Run-Length Encoding (RLE), Floating Point Compression (FPC) and binary packing.

These techniques are particularly important when dealing with large volumes of data that need to be queried in real-time or near-real-time. Proper optimization not only saves time and resources but also improves the overall performance of the system.

Choose the right compression algorithm based on the specific requirements of the use case. For example, some algorithms may work better for data with a lot of repeated patterns, while others may be more effective for data with a lot of noise or randomness.

Ultimately, the choice of compression algorithm will depend on factors like data volume, query performance requirements and the level of compression needed.

Optimizing Database Schema

A well-designed database schema can improve query performance, reduce storage space, and provide better data quality. Here are some methods for optimizing database schema for time series data

Normalize the data. Normalization involves breaking down the data into smaller, atomic units to reduce redundancy and improve query performance. For time series data, this could involve splitting the data into separate tables based on different time intervals or granularities.

Use appropriate data types. Choosing the right data type for each column can also improve storage efficiency and query performance. For example, using integer data types for numeric values instead of floating-point data types can reduce storage space and improve query performance.

Implement indexing. Indexing is a technique used to speed up data retrieval by creating a separate data structure that stores the values of one or more columns. For time series data, indexing by timestamp or by tag can improve query performance.

Use partitioning. Partitioning involves splitting the data into smaller chunks and storing them on separate physical devices or servers. This can improve query performance by allowing the database to distribute the workload across multiple nodes.

Optimize for compression. Time series data is often highly compressible due to its repetitive nature. Using compression techniques such as delta encoding, run-length encoding or dictionary encoding can significantly reduce storage space and improve query performance.

Tips for Optimizing Queries

By optimizing queries, users can significantly improve their database’s performance and query response times. Here are some essential tips for optimizing queries in time series databases.

Understand query patterns. Users should identify the common query types they perform on their time-series data, such as range queries or aggregation queries. Query profiling and analysis can help identify query patterns and provide insights into optimizing query performance.

Choose the right database engine. There are many time series database engines available, such as TimescaleDB, InfluxDB, and Prometheus, each with unique features and capabilities. Users should evaluate their use case and select the database engine that best fits their needs.

Tune query performance. Monitoring query performance can help identify slow queries and improve their performance by tuning database configuration settings, such as adjusting memory allocation or changing indexing strategies.

Distribute data across nodes through partitioning and sharding. Data can be partitioned by time or tag, and sharding can help distribute data across multiple nodes to improve query performance and reduce latency.

Use caching. Caching can be used to store frequently accessed data and reduce the number of queries needed. This can help to improve query performance and reduce resource usage.

Use appropriate hardware. Use hardware that is optimized for time series data storage and processing. This can include specialized hardware components such as GPUs and FPGAs.

Tips for Writing Efficient Queries

Here are some final tips to help you write queries for time series data that will help retrieve results efficiently and accurately.

Use indexes. Indexes can speed up query execution by allowing the database to quickly locate relevant data. For time series data, indexes can be created on timestamp or tag columns to enable efficient filtering and aggregation.

Minimize data retrieval. Only retrieve the data you need. Use filters to narrow down the results and limit the number of rows returned. This can significantly reduce query execution time and resource usage.

Use appropriate time intervals. Choose the right time intervals for aggregation and downsampling. Using smaller intervals can provide more accurate results, but it can also lead to increased resource usage. Using larger intervals can reduce resource usage but may sacrifice accuracy.

Optimize joins. Avoid joins if possible or minimize the number of joins needed. Joining large tables can significantly slow down query execution.

Use the right data model. Choose a data model that fits the specific needs of your application. For example, if you have a high volume of writes, consider using a column-oriented data model. If you need to perform complex queries, consider using a relational data model.

Avoid using wildcards. Avoid using wildcards like % in your queries, as they can cause the database to perform a full table scan. Instead, use specific criteria in your query to narrow down the results.

Use batch operations. Batch operations will perform multiple operations in a single query, rather than executing multiple individual queries. This can reduce the overhead of query execution and improve performance.

Use prepared statements. Parameterized queries will reduce the overhead of query compilation and execution. Prepared statements allow you to reuse the same query multiple times with different parameter values.

Use the correct data type. Using a data type that’s not optimized for timestamps can lead to slower queries and increased resource usage. For example, use a “timestamp” data type instead of a “datetime” data type.

Use pre-aggregation. Pre-aggregation involves calculating aggregate values ahead of time and storing them in a separate table. This can help to speed up queries that require aggregation by reducing the amount of data that needs to be scanned.

Group Created with Sketch.
TNS owner Insight Partners is an investor in: Pragma.
THE NEW STACK UPDATE A newsletter digest of the week’s most important stories & analyses.