TigerData logo
TigerData logo
  • Product

    Tiger Cloud

    Robust elastic cloud platform for startups and enterprises

    Agentic Postgres

    Postgres for Agents

    TimescaleDB

    Postgres for time-series, real-time analytics and events

  • Docs
  • Pricing

    Pricing

    Enterprise Tier

  • Developer Hub

    Changelog

    Benchmarks

    Blog

    Community

    Customer Stories

    Events

    Support

    Integrations

    Launch Hub

  • Company

    Contact us

    About

    Timescale

    Partners

    Security

    Careers

Log InTry for free
Home
Is Your Data Time Series? Data Types Supported by PostgreSQL and TimescaleUnderstanding Database Workloads: Variable, Bursty, and Uniform PatternsTime-Series Analysis and Forecasting With Python What Is Temporal Data?What Are Open-Source Time-Series Databases—Understanding Your OptionsAWS Time-Series Database: Understanding Your OptionsStationary Time-Series AnalysisThe Best Time-Series Databases ComparedAlternatives to TimescaleWhy Consider Using PostgreSQL for Time-Series Data?Time-Series Analysis in RWhat Is a Time Series and How Is It Used?How to Work With Time Series in Python?Tools for Working With Time-Series Analysis in PythonGuide to Time-Series Analysis in PythonUnderstanding Autoregressive Time-Series ModelingCreating a Fast Time-Series Graph With Postgres Materialized Views
Optimizing Your Database: A Deep Dive into PostgreSQL Data TypesHow to Install PostgreSQL on LinuxUnderstanding FROM in PostgreSQL (With Examples)How to Address ‘Error: Could Not Resize Shared Memory Segment’ Understanding FILTER in PostgreSQL (With Examples)How to Install PostgreSQL on MacOS5 Common Connection Errors in PostgreSQL and How to Solve ThemUnderstanding HAVING in PostgreSQL (With Examples)How to Fix No Partition of Relation Found for Row in Postgres DatabasesHow to Fix Transaction ID Wraparound ExhaustionUnderstanding LIMIT in PostgreSQL (With Examples)Understanding PostgreSQL FunctionsUnderstanding ORDER BY in PostgreSQL (With Examples)PostgreSQL Mathematical Functions: Enhancing Coding EfficiencyUnderstanding PostgreSQL WITHIN GROUPUnderstanding WINDOW in PostgreSQL (With Examples)Using PostgreSQL String Functions for Improved Data AnalysisPostgreSQL Joins : A SummaryUnderstanding PostgreSQL Conditional FunctionsStructured vs. Semi-Structured vs. Unstructured Data in PostgreSQLUnderstanding DISTINCT in PostgreSQL (With Examples)What Is a PostgreSQL Cross Join?Understanding percentile_cont() and percentile_disc() in PostgreSQLUnderstanding GROUP BY in PostgreSQL (With Examples)Data Processing With PostgreSQL Window FunctionsUnderstanding WHERE in PostgreSQL (With Examples)Data Partitioning: What It Is and Why It MattersUnderstanding PostgreSQL Array FunctionsUnderstanding ACID Compliance Understanding PostgreSQL's COALESCE FunctionUnderstanding the rank() and dense_rank() Functions in PostgreSQLUnderstanding PostgreSQLUnderstanding OFFSET in PostgreSQL (With Examples)Understanding PostgreSQL Date and Time FunctionsUnderstanding the Postgres string_agg FunctionWhat Is a PostgreSQL Full Outer Join?What Is a PostgreSQL Inner Join?What Is a PostgreSQL Left Join? And a Right Join?Strategies for Improving Postgres JOIN PerformancePostgreSQL Join Type TheoryA Guide to PostgreSQL ViewsUnderstanding Foreign Keys in PostgreSQLUnderstanding PostgreSQL User-Defined FunctionsUnderstanding SQL Aggregate FunctionsUsing PostgreSQL UPDATE With JOINWhat Is Data Compression and How Does It Work?What Is Data Transformation, and Why Is It Important?What Characters Are Allowed in PostgreSQL Strings?Understanding PostgreSQL SELECTSelf-Hosted or Cloud Database? A Countryside Reflection on Infrastructure ChoicesUnderstanding the Postgres extract() Function
How to Choose a Database: A Decision Framework for Modern ApplicationsHandling Large Objects in PostgresDetermining the Optimal Postgres Partition SizeNavigating Growing PostgreSQL Tables With Partitioning (and More)SQL/JSON Data Model and JSON in SQL: A PostgreSQL PerspectiveHow to Use PostgreSQL for Data TransformationPostgreSQL Performance Tuning: Designing and Implementing Your Database SchemaGuide to PostgreSQL PerformancePostgreSQL Performance Tuning: Key ParametersPostgreSQL Performance Tuning: Optimizing Database IndexesHow to Reduce Bloat in Large PostgreSQL TablesAn Intro to Data Modeling on PostgreSQLDesigning Your Database Schema: Wide vs. Narrow Postgres TablesGuide to PostgreSQL Database OperationsBest Practices for Time-Series Data Modeling: Single or Multiple Partitioned Table(s) a.k.a. Hypertables Explaining PostgreSQL EXPLAINWhat Is a PostgreSQL Temporary View?PostgreSQL Performance Tuning: How to Size Your DatabaseBest Practices for (Time-)Series Metadata Tables A PostgreSQL Database Replication GuideHow to Compute Standard Deviation With PostgreSQLA Guide to Data Analysis on PostgreSQLA Guide to Scaling PostgreSQLRecursive Query in SQL: What It Is, and How to Write OneHow to Query JSON Metadata in PostgreSQLHow to Query JSONB in PostgreSQLGuide to PostgreSQL SecurityOptimizing Array Queries With GIN Indexes in PostgreSQLPg_partman vs. Hypertables for Postgres PartitioningTop PostgreSQL Drivers for PythonUnderstanding PostgreSQL TablespacesWhat Is Audit Logging and How to Enable It in PostgreSQLWhen to Consider Postgres PartitioningGuide to Postgres Data ManagementHow to Index JSONB Columns in PostgreSQLHow to Monitor and Optimize PostgreSQL Index PerformanceA Guide to pg_restore (and pg_restore Example)How PostgreSQL Data Aggregation WorksHow to Use Psycopg2: The PostgreSQL Adapter for PythonBuilding a Scalable DatabaseGuide to PostgreSQL Database Design
Best Practices for Postgres Data ManagementHow to Store Video in PostgreSQL Using BYTEABest Practices for Postgres PerformanceHow to Design Your PostgreSQL Database: Two Schema ExamplesBest Practices for Scaling PostgreSQLHow to Handle High-Cardinality Data in PostgreSQLBest Practices for PostgreSQL AggregationBest Practices for Postgres Database ReplicationHow to Use a Common Table Expression (CTE) in SQLBest Practices for Postgres SecurityBest Practices for PostgreSQL Database OperationsBest Practices for PostgreSQL Data AnalysisTesting Postgres Ingest: INSERT vs. Batch INSERT vs. COPYHow to Manage Your Data With Data Retention PoliciesHow to Use PostgreSQL for Data Normalization
PostgreSQL Extensions: amcheckPostgreSQL Extensions: Unlocking Multidimensional Points With Cube PostgreSQL Extensions: hstorePostgreSQL Extensions: ltreePostgreSQL Extensions: Secure Your Time-Series Data With pgcryptoPostgreSQL Extensions: pg_prewarmPostgreSQL Extensions: pgRoutingPostgreSQL Extensions: pg_stat_statementsPostgreSQL Extensions: Database Testing With pgTAPPostgreSQL Extensions: Install pg_trgm for Data MatchingPostgreSQL Extensions: PL/pgSQLPostgreSQL Extensions: Using PostGIS and Timescale for Advanced Geospatial InsightsPostgreSQL Extensions: Turning PostgreSQL Into a Vector Database With pgvectorPostgreSQL Extensions: Intro to uuid-ossp
What Is ClickHouse and How Does It Compare to PostgreSQL and TimescaleDB for Time Series?Timescale vs. Amazon RDS PostgreSQL: Up to 350x Faster Queries, 44 % Faster Ingest, 95 % Storage Savings for Time-Series DataWhat We Learned From Benchmarking Amazon Aurora PostgreSQL ServerlessTimescaleDB vs. Amazon Timestream: 6,000x Higher Inserts, 5-175x Faster Queries, 150-220x CheaperHow to Store Time-Series Data in MongoDB and Why That’s a Bad IdeaPostgreSQL + TimescaleDB: 1,000x Faster Queries, 90 % Data Compression, and Much MoreEye or the Tiger: Benchmarking Cassandra vs. TimescaleDB for Time-Series Data
Moving Past Legacy Systems: Data Historian vs. Time-Series DatabaseHow Hopthru Powers Real-Time Transit Analytics From a 1 TB TableUnderstanding IoT (Internet of Things)A Beginner’s Guide to IIoT and Industry 4.0Storing IoT Data: 8 Reasons Why You Should Use PostgreSQLHow to Choose an IoT DatabaseHow to Simulate a Basic IoT Sensor Dataset on PostgreSQLFrom Ingest to Insights in Milliseconds: Everactive's Tech Transformation With TimescaleHow Ndustrial Is Providing Fast Real-Time Queries and Safely Storing Client Data With 97 % CompressionWhy You Should Use PostgreSQL for Industrial IoT Data Migrating a Low-Code IoT Platform Storing 20M Records/DayHow United Manufacturing Hub Is Introducing Open Source to ManufacturingBuilding IoT Pipelines for Faster Analytics With IoT CoreVisualizing IoT Data at Scale With Hopara and TimescaleDB
Building AI Agents with Persistent Memory: A Unified Database ApproachA Brief History of AI: How Did We Get Here, and What's Next?A Beginner’s Guide to Vector EmbeddingsPostgreSQL as a Vector Database: A Pgvector TutorialUsing Pgvector With PythonHow to Choose a Vector DatabaseVector Databases Are the Wrong AbstractionUnderstanding DiskANNA Guide to Cosine SimilarityStreaming DiskANN: How We Made PostgreSQL as Fast as Pinecone for Vector DataImplementing Cosine Similarity in PythonVector Database Basics: HNSWVector Database Options for AWSVector Store vs. Vector Database: Understanding the ConnectionPgvector vs. Pinecone: Vector Database Performance and Cost ComparisonHow to Build LLM Applications With Pgvector Vector Store in LangChainHow to Implement RAG With Amazon Bedrock and LangChainRetrieval-Augmented Generation With Claude Sonnet 3.5 and PgvectorRAG Is More Than Just Vector SearchImplementing Filtered Semantic Search Using Pgvector and JavaScriptWhen Should You Use Full-Text Search vs. Vector Search?HNSW vs. DiskANNPostgreSQL Hybrid Search Using Pgvector and CohereRefining Vector Search Queries With Time Filters in Pgvector: A TutorialUnderstanding Semantic SearchWhat Is Vector Search? Vector Search vs Semantic SearchText-to-SQL: A Developer’s Zero-to-Hero GuideNearest Neighbor Indexes: What Are IVFFlat Indexes in Pgvector and How Do They WorkBuilding an AI Image Gallery With OpenAI CLIP, Claude Sonnet 3.5, and Pgvector
How to Choose a Real-Time Analytics DatabaseData Analytics vs. Real-Time Analytics: How to Pick Your Database (and Why It Should Be PostgreSQL)Understanding OLTPOLAP Workloads on PostgreSQL: A GuideColumnar Databases vs. Row-Oriented Databases: Which to Choose?How to Choose an OLAP DatabasePostgreSQL as a Real-Time Analytics DatabaseWhat Is the Best Database for Real-Time AnalyticsHow to Build an IoT Pipeline for Real-Time Analytics in PostgreSQL
Alternatives to RDSWhy Is RDS so Expensive? Understanding RDS Pricing and CostsEstimating RDS CostsHow to Migrate From AWS RDS for PostgreSQL to TimescaleAmazon Aurora vs. RDS: Understanding the Difference
5 InfluxDB Alternatives for Your Time-Series Data8 Reasons to Choose Timescale as Your InfluxDB Alternative InfluxQL, Flux, and SQL: Which Query Language Is Best? (With Cheatsheet)What InfluxDB Got WrongTimescaleDB vs. InfluxDB: Purpose Built Differently for Time-Series Data
Is Postgres Partitioning Really That Hard? An Introduction To HypertablesComplete Guide: Migrating from MongoDB to Tiger Data (Step-by-Step)How to Migrate Your Data to Timescale (3 Ways)Postgres TOAST vs. Timescale CompressionBuilding Python Apps With PostgreSQL: A Developer's GuideData Visualization in PostgreSQL With Apache SupersetMore Time-Series Data Analysis, Fewer Lines of Code: Meet HyperfunctionsPostgreSQL Materialized Views and Where to Find Them5 Ways to Monitor Your PostgreSQL DatabaseTimescale Tips: Testing Your Chunk Size
Postgres cheat sheet
HomeTime series basicsPostgres basicsPostgres guidesPostgres best practicesPostgres extensionsBenchmarks
Sections

Postgres overview

Understanding PostgreSQLOptimizing Your Database: A Deep Dive into PostgreSQL Data Types

Postgres errors

How to Address ‘Error: Could Not Resize Shared Memory Segment’ 5 Common Connection Errors in PostgreSQL and How to Solve ThemHow to Fix No Partition of Relation Found for Row in Postgres DatabasesHow to Fix Transaction ID Wraparound Exhaustion

Install postgres

How to Install PostgreSQL on LinuxHow to Install PostgreSQL on MacOS

Postgres functions

Understanding PostgreSQL FunctionsPostgreSQL Mathematical Functions: Enhancing Coding EfficiencyUsing PostgreSQL String Functions for Improved Data AnalysisData Processing With PostgreSQL Window FunctionsUnderstanding PostgreSQL Date and Time FunctionsUnderstanding the Postgres string_agg FunctionUnderstanding PostgreSQL Conditional FunctionsUnderstanding percentile_cont() and percentile_disc() in PostgreSQLUnderstanding PostgreSQL Array FunctionsUnderstanding PostgreSQL's COALESCE FunctionUnderstanding the rank() and dense_rank() Functions in PostgreSQLUnderstanding PostgreSQL User-Defined FunctionsUnderstanding SQL Aggregate FunctionsUnderstanding the Postgres extract() Function

Postgres clauses

Understanding FROM in PostgreSQL (With Examples)Understanding FILTER in PostgreSQL (With Examples)Understanding HAVING in PostgreSQL (With Examples)Understanding GROUP BY in PostgreSQL (With Examples)Understanding LIMIT in PostgreSQL (With Examples)Understanding ORDER BY in PostgreSQL (With Examples)Understanding PostgreSQL WITHIN GROUPUnderstanding WINDOW in PostgreSQL (With Examples)Understanding DISTINCT in PostgreSQL (With Examples)Understanding WHERE in PostgreSQL (With Examples)Understanding OFFSET in PostgreSQL (With Examples)

Postgres joins

PostgreSQL Joins : A SummaryWhat Is a PostgreSQL Cross Join?What Is a PostgreSQL Full Outer Join?What Is a PostgreSQL Inner Join?What Is a PostgreSQL Left Join? And a Right Join?PostgreSQL Join Type TheoryStrategies for Improving Postgres JOIN Performance

Postgres operations

A Guide to PostgreSQL ViewsData Partitioning: What It Is and Why It MattersWhat Is Data Compression and How Does It Work?Self-Hosted or Cloud Database? A Countryside Reflection on Infrastructure Choices

More

Understanding ACID Compliance Structured vs. Semi-Structured vs. Unstructured Data in PostgreSQLUnderstanding Foreign Keys in PostgreSQL

Postgres statements

Understanding PostgreSQL SELECTUsing PostgreSQL UPDATE With JOINWhat Characters Are Allowed in PostgreSQL Strings?

Data analysis

What Is Data Transformation, and Why Is It Important?
TigerData logo

Products

Time-series and Analytics AI and Vector Enterprise Plan Cloud Status Support Security Cloud Terms of Service

Learn

Documentation Blog Tutorials Changelog Success Stories Time-series Database

Company

Contact Us Careers About Brand Community Code Of Conduct Events

Subscribe to the Tiger Data Newsletter

By submitting, you acknowledge Tiger Data's Privacy Policy

2026 (c) Timescale, Inc., d/b/a Tiger Data. All rights reserved.

Privacy preferences
LegalPrivacySitemap

Published at Jul 4, 2024

Understanding ORDER BY in PostgreSQL (With Examples)

Abstract shapes over a dark background.

Written by Team Timescale

The ORDER BY clause in PostgreSQL or TimescaleDB allows you to sort the result set of a query by one or more columns in either ascending or descending order. By default, the sorting is in ascending order. However, you can specify descending order if needed.

PostgreSQL ORDER BY: Syntax

The basic syntax of the ORDER BY clause is as follows:

SELECT column1, column2, … FROM table ORDER BY column1 [ASC | DESC], column2 [ASC | DESC], ...;

Example table

Let's consider a table weather_data with the following structure and data:

CREATE TABLE weather_data (     id SERIAL PRIMARY KEY,     device_id VARCHAR(50),     temperature NUMERIC,     humidity NUMERIC,     wind_speed NUMERIC,     recorded_at TIMESTAMP );

INSERT INTO weather_data (device_id, temperature, humidity, wind_speed, recorded_at) VALUES ('device_1', 22.5, 55.0, 12.5, '2023-01-15 08:00:00'), ('device_2', 21.0, 60.0, 10.0, '2023-01-15 08:05:00'), ('device_1', 23.0, 57.0, 11.0, '2023-01-15 08:10:00'), ('device_2', 19.5, 62.0, 8.0, '2023-01-15 08:15:00'), ('device_1', 20.0, 59.0, 9.5, '2023-01-15 08:20:00'), ('device_3', 24.0, 54.0, 13.0, '2023-01-15 08:25:00'), ('device_2', 18.5, 63.0, 7.5, '2023-01-15 08:30:00'), ('device_3', 22.0, 55.5, 12.0, '2023-01-15 08:35:00'), ('device_1', 21.5, 58.0, 10.5, '2023-01-15 08:40:00'), ('device_3', 23.5, 53.0, 13.5, '2023-01-15 08:45:00');

Practical examples with the ORDER BY clause

Let's dive into some examples to see the ORDER BY clause in action.

Example 1: Sorting by a single column

Suppose we want to retrieve all weather data sorted by temperature in ascending order. We can use the ORDER BY clause to achieve this:

SELECT id, device_id, temperature, humidity, wind_speed, recorded_at FROM weather_data ORDER BY temperature ASC;

Result:

 id | device_id | temperature | humidity | wind_speed |     recorded_at       ----+-----------+-------------+----------+------------+---------------------   7 | device_2  |        18.5 |     63.0 |        7.5 | 2023-01-15 08:30:00   4 | device_2  |        19.5 |     62.0 |        8.0 | 2023-01-15 08:15:00   5 | device_1  |        20.0 |     59.0 |        9.5 | 2023-01-15 08:20:00   2 | device_2  |        21.0 |     60.0 |       10.0 | 2023-01-15 08:05:00   9 | device_1  |        21.5 |     58.0 |       10.5 | 2023-01-15 08:40:00   1 | device_1  |        22.5 |     55.0 |       12.5 | 2023-01-15 08:00:00   8 | device_3  |        22.0 |     55.5 |       12.0 | 2023-01-15 08:35:00   3 | device_1  |        23.0 |     57.0 |       11.0 | 2023-01-15 08:10:00  10 | device_3  |        23.5 |     53.0 |       13.5 | 2023-01-15 08:45:00   6 | device_3  |        24.0 |     54.0 |       13.0 | 2023-01-15 08:25:00

This query sorts the rows by the temperature column in ascending order.

Example 2: Sorting by multiple columns

Now, let's say we want to sort the weather data first by device_id and then by recorded_at in ascending order. We can use the ORDER BY clause with multiple columns:

SELECT id, device_id, temperature, humidity, wind_speed, recorded_at FROM weather_data ORDER BY device_id ASC, recorded_at ASC;

Result:

 id | device_id | temperature | humidity | wind_speed |     recorded_at       ----+-----------+-------------+----------+------------+---------------------   1 | device_1  |        22.5 |     55.0 |       12.5 | 2023-01-15 08:00:00   3 | device_1  |        23.0 |     57.0 |       11.0 | 2023-01-15 08:10:00   5 | device_1  |        20.0 |     59.0 |        9.5 | 2023-01-15 08:20:00   9 | device_1  |        21.5 |     58.0 |       10.5 | 2023-01-15 08:40:00   2 | device_2  |        21.0 |     60.0 |       10.0 | 2023-01-15 08:05:00   4 | device_2  |        19.5 |     62.0 |        8.0 | 2023-01-15 08:15:00   7 | device_2  |        18.5 |     63.0 |        7.5 | 2023-01-15 08:30:00   6 | device_3  |        24.0 |     54.0 |       13.0 | 2023-01-15 08:25:00   8 | device_3  |        22.0 |     55.5 |       12.0 | 2023-01-15 08:35:00  10 | device_3  |        23.5 |     53.0 |       13.5 | 2023-01-15 08:45:00

This query sorts the rows first by device_id and then by recorded_at in ascending order.

Example 3: Sorting by descending order

Suppose we want to retrieve the weather data sorted by humidity in descending order. We can use the ORDER BY clause with DESC:

SELECT id, device_id, temperature, humidity, wind_speed, recorded_at FROM weather_data ORDER BY humidity DESC;

Result:

id | device_id | temperature | humidity | wind_speed |     recorded_at       ----+-----------+-------------+----------+------------+---------------------   7 | device_2  |        18.5 |     63.0 |        7.5 | 2023-01-15 08:30:00   4 | device_2  |        19.5 |     62.0 |        8.0 | 2023-01-15 08:15:00   2 | device_2  |        21.0 |     60.0 |       10.0 | 2023-01-15 08:05:00   5 | device_1  |        20.0 |     59.0 |        9.5 | 2023-01-15 08:20:00   9 | device_1  |        21.5 |     58.0 |       10.5 | 2023-01-15 08:40:00   3 | device_1  |        23.0 |     57.0 |       11.0 | 2023-01-15 08:10:00   8 | device_3  |        22.0 |     55.5 |       12.0 | 2023-01-15 08:35:00   1 | device_1  |        22.5 |     55.0 |       12.5 | 2023-01-15 08:00:00   6 | device_3  |        24.0 |     54.0 |       13.0 | 2023-01-15 08:25:00  10 | device_3  |        23.5 |     53.0 |       13.5 | 2023-01-15 08:45:00

This query sorts the rows by the humidity column in descending order.

Example 4: Combining ORDER BY with LIMIT

We can also combine ORDER BY with LIMIT to retrieve a specific number of sorted rows. For instance, to get the top three highest wind speeds recorded:

SELECT id, device_id, temperature, humidity, wind_speed, recorded_at FROM weather_data ORDER BY wind_speed DESC LIMIT 3;

Result:

id | device_id | temperature | humidity | wind_speed |     recorded_at       ----+-----------+-------------+----------+------------+---------------------  10 | device_3  |        23.5 |     53.0 |       13.5 | 2023-01-15 08:45:00   6 | device_3  |        24.0 |     54.0 |       13.0 | 2023-01-15 08:25:00   1 | device_1  |        22.5 |     55.0 |       12.5 | 2023-01-15 08:00:00 This query sorts the rows by wind_speed in descending order and returns the top three rows.

Conclusion

The ORDER BY clause is a fundamental part of SQL and PostgreSQL that allows you to sort query results based on specified columns. To learn more about ORDER BY, check out the PostgreSQL documentation. If you want to learn more about other PostgreSQL clauses and basics, visit our Postgres basics section.

On this page