Summary
This chapter explains how to control the sort direction in an SQL ORDER BY clause using the DESC keyword for descending order, including how to apply it selectively to single or multiple columns.

General domain of usage
Relational database querying

## Sarakkeiden lajittelu laskevaan järjestykseen

Voit tehdä muutakin kuin vain lajitella tietoja nousevaan järjestykseen oletuksena. `ORDER BY` -lauseke voi järjestää tietoja myös laskevaan järjestykseen, mikä vaatii `DESC`-avainsanan käyttöä.

SELECT continent 
FROM country 
ORDER BY continent DESC;

## Useiden sarakkeiden lajittelu laskevaan järjestykseen

Voit lajitella tietoja useiden sarakkeiden mukaan, ja monissa tapauksissa tämä onkin tarpeellista. Kun näytetään opiskelijalistaa, opiskelijat voidaan järjestää ensin sukunimen ja sitten etunimen mukaan. Tämä on erityisen hyödyllistä silloin, kun usealla opiskelijalla on sama nimi.

Jos lajittelet useamman kuin yhden sarakkeen laskevaan järjestykseen, muista, että jokaisella sarakkeella tulee olla oma `DESC`-avainsanansa.

SELECT id, name, region 
FROM country 
ORDER BY region, name DESC;

`DESC`-avainsana tulee lisätä vain siihen sarakkeeseen, jonka haluat lajitella laskevaan järjestykseen. Esimerkissämme `DESC` on käytetty `name`-sarakkeessa, mutta ei `region`-sarakkeessa. Tämän seurauksena `name`-sarake lajitellaan laskevaan järjestykseen, kun taas `region`-sarake pysyy nousevassa järjestyksessä (oletus).

import unittest
import psycopg2
import pandas as pd

class TestTask(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.connection = psycopg2.connect(
            host="localhost",
            user="agent",
            password="qwerty",
            dbname="testdb",
            sslmode="disable"
        )
        cls.cursor = cls.connection.cursor()

    def test_selects_five_columns_in_order(self):
        """Test that the query selects columns in the correct order: name, continent, region, population, capital."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        expected_columns = ["name", "continent", "region", "population", "capital"]
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "Query selects the correct columns in the correct order.",
            f"Columns selected are {columns}, but expected {expected_columns}."
        )

    def test_order_by_continent_desc_population_asc(self):
        """Test that the result is ordered by continent DESC, then population ASC."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        # Get the indexes for continent and population
        columns = [desc[0] for desc in self.cursor.description]
        continent_idx = columns.index("continent")
        population_idx = columns.index("population")
        # Prepare list of (continent, population) for comparison
        order_pairs = [(row[continent_idx], row[population_idx]) for row in rows]
        # Compare with expected ordering
        sorted_pairs = sorted(order_pairs, key=lambda x: (x[0] is not None and x[0] or '', x[1] if x[1] is not None else float('inf')), reverse=False)
        # continent DESC, population ASC
        # So, for continent, need descending
        sorted_pairs = sorted(order_pairs, key=lambda x: ((x[0] is not None and x[0] or ''), x[1] if x[1] is not None else float('inf')))
        sorted_pairs = sorted(sorted_pairs, key=lambda x: (x[0] is not None and x[0] or ''), reverse=True)
        # Now, compare to actual
        # But above sorts in two steps: first by population ASC, then by continent DESC
        # Instead, use a tuple: (-continent, population) but continent is string
        # So, do a single sort:
        expected_pairs = sorted(order_pairs, key=lambda x: ((x[0] is not None and x[0] or ''), x[1] if x[1] is not None else float('inf')), reverse=False)
        expected_pairs = sorted(expected_pairs, key=lambda x: (x[0] is not None and x[0] or ''), reverse=True)
        condition = order_pairs == expected_pairs
        _dynamic_test(
            self,
            condition,
            "Rows are ordered by continent DESC, then population ASC.",
            "Rows are not ordered by continent DESC, then population ASC."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

if __name__ == "__main__":
    unittest.main()


test_solution.py

Tutustu SQL:n perusteisiin – tiedon hakemisesta sen integrointiin käytännön sovelluksiin. Olitpa vasta aloittamassa tietokantojen hallintaa tai haluat hyödyntää SQL:ää sovelluskehityksessä, tämä kurssi kattaa olennaiset asiat. Opit nopeasti hyödyntämään SQL:n koko potentiaalia tiedon hakemisesta ja hallinnasta sen sujuvaan integrointiin todellisiin sovelluksiin. Kurssin lopussa hallitset käytännön ongelmien ratkaisun SQL:llä ja kehitysprosessisi tehostuu.

Tässä osiossa opitaan käyttämään SQL SELECT -lausetta yksittäisen taulun sarakkeen, useiden taulun sarakkeiden ja kaikkien taulun sarakkeiden hakemiseen. Lisäksi selvitetään, miten palautetaan yksilölliset arvot.

Tässä osiossa tarkastellaan, kuinka kyselyn palauttamaa dataa voidaan järjestää ja priorisoida ORDER BY -lauseen avulla. Tämä lause sijoitetaan SELECT-lauseen loppuun ja sen avulla tulokset voidaan lajitella yhden tai useamman sarakkeen perusteella joko nousevaan tai laskevaan järjestykseen, mikä mahdollistaa merkityksellisemmän ja helpommin tulkittavan datan esittämisen.

Tässä osiossa opitaan suodattamaan palautettuja tietoja SELECT-lauseen WHERE-ehdon avulla. Käsitellään yhtäsuuruuden, erisuuruuden, suurempien ja pienempien arvojen sekä NULL-arvojen testaamista.

Tässä osiossa perehdytään hakuehtojen tarkentamiseen yhdistämällä WHERE-lausekkeita AND- ja OR-operaattoreiden avulla. Lisäksi käsitellään, miten NOT-operaattoria voidaan käyttää tiettyjen tulosten poissulkemiseen.

Tässä osiossa opimme, mitä SQL:n aggregaattifunktiot ovat ja kuinka niitä käytetään taulukoiden tietojen yhteenvedossa.

Lajittelusuunnan Määrittäminen

Sarakkeiden lajittelu laskevaan järjestykseen

Useiden sarakkeiden lajittelu laskevaan järjestykseen

Ratkaisu