Summary  
This chapter explains how to sort query results by multiple columns in a specified priority order by listing column names separated by commas in the ORDER BY clause.  

General domain of usage  
Relational database querying

Voit myös lajitella useamman sarakkeen perusteella. Sinun tulee määrittää sarakkeiden nimet **pilkuilla eroteltuna**.

Ensimmäisenä mainitulla sarakkeella on **ensisijaisuus**, ja lajittelu jatkuu seuraavan sarakkeen mukaan.

Syntaksi näyttää tältä:

```sql
SELECT columns 
FROM table 
ORDER BY column_with_priority, column2, ...
```

Tässä esimerkissä haetaan kolme saraketta ja lajitellaan tulokset kahden sarakkeen perusteella – ensin `population` ja sitten `capital`:

SELECT ID, population, capital 
FROM country 
ORDER BY population, capital;

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_correct_columns_and_order(self):
        """Check that the query selects exactly the columns: continent, region, population, capital in that order."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        colnames = [desc[0] for desc in self.cursor.description]
        expected = ["continent", "region", "population", "capital"]
        condition = colnames == expected
        _dynamic_test(
            self,
            condition,
            "Query selects columns in correct order.",
            f"Expected columns {expected}, got {colnames}."
        )

    def test_order_by_continent_population(self):
        """Check that the result is ordered first by continent, then by population (ascending)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        if not rows or len(rows) < 2:
            _dynamic_test(
                self,
                True,
                "Result has less than 2 rows, ordering cannot be tested.",
                ""
            )
            return
        df = pd.DataFrame(rows, columns=[desc[0] for desc in self.cursor.description])
        # Sort with pandas to expected order
        expected_df = df.sort_values(by=["continent", "population"], ascending=[True, True], na_position='last').reset_index(drop=True)
        user_df = df.reset_index(drop=True)
        condition = expected_df[["continent", "population"]].equals(user_df[["continent", "population"]])
        _dynamic_test(
            self,
            condition,
            "Rows are ordered by continent and then by population.",
            "Rows are not ordered by continent and then by population."
        )

    def test_selects_from_country_table(self):
        """Check that the query selects from the country table (by verifying result matches expected rows from country table)."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        self.cursor.execute("SELECT continent, region, population, capital FROM country ORDER BY continent, population;")
        expected_rows = self.cursor.fetchall()
        condition = user_rows == expected_rows
        _dynamic_test(
            self,
            condition,
            "Query retrieves correct rows from country table.",
            "Query does not retrieve correct rows from country table."
        )

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.

Lajittelu Useiden Sarakkeiden Mukaan

Ratkaisu