Summary  
The chapter explains how to use the asterisk wildcard in SQL’s SELECT statement to retrieve every column from a table without naming each column individually.  

General domain of usage  
Data analysis

Watch this video to see how you can retrieve all columns from a table using the asterisk symbol (*) in an SQL SELECT statement. You'll learn how to quickly display every column and row from a table, making it easy to explore all available data without typing each column name individually.

Anstelle jeder Spalte einzeln aufzulisten, kann das Sternchen `*` verwendet werden, um alle Spalten einer Tabelle gleichzeitig abzurufen. Dies ist besonders nützlich, wenn alle Daten einer Tabelle angezeigt werden sollen, ohne jeden Spaltennamen manuell eingeben zu müssen. Hier ein Beispiel:

import unittest
import psycopg2
import pandas as pd
import re

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_query_selects_all_columns_with_asterisk(self):
        """Check that the query uses '*' to select all columns from country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Normalize whitespace and lowercase
        norm_query = normalize_text(query)
        # Check for correct pattern
        condition = (
            'select * from country' in norm_query or
            'select*from country' in norm_query or
            'select *from country' in norm_query or
            'select* from country' in norm_query
        )
        _dynamic_test(
            self,
            condition,
            "Query uses '*' to select all columns from country table.",
            "Query does not use '*' to select all columns from country table."
        )

    def test_query_returns_all_columns(self):
        """Check that the query result returns all 7 columns from country table."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        result_columns = [desc[0] for desc in self.cursor.description]
        # Get actual columns from country table
        self.cursor.execute("SELECT * FROM country LIMIT 1")
        expected_columns = [desc[0] for desc in self.cursor.description]
        condition = result_columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "Query returns all columns from country table.",
            f"Query does not return all columns. Expected: {expected_columns}, Got: {result_columns}"
        )

    def test_query_returns_all_rows(self):
        """Check that the query returns all rows from the 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 * FROM country")
        expected_rows = self.cursor.fetchall()
        condition = len(user_rows) == len(expected_rows)
        _dynamic_test(
            self,
            condition,
            "Query returns all rows from country table.",
            f"Query does not return all rows. Expected {len(expected_rows)} rows, got {len(user_rows)} rows."
        )

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

Dieser Kurs ist ideal für Anfänger, die bereit sind, die Welt von SQL zu erkunden. Egal, ob Sie gerade erst mit dem Datenbankmanagement beginnen oder SQL für Ihre Anwendungsentwicklungsprojekte nutzen möchten, dieser Kurs behandelt die Grundlagen. Sie lernen schnell, das volle Potenzial von SQL auszuschöpfen – von der Abfrage und Verwaltung von Daten bis hin zur nahtlosen Integration in reale Anwendungen. Am Ende des Kurses verfügen Sie über das nötige Selbstvertrauen und die Fähigkeiten, um praktische Probleme mit SQL zu lösen und Ihren Entwicklungsprozess zu optimieren.

In diesem Abschnitt erfahren wir, wie die SQL-SELECT-Anweisung verwendet wird, um eine einzelne Tabellenspalte, mehrere Tabellenspalten und alle Tabellenspalten abzurufen. Außerdem wird erläutert, wie eindeutige Werte zurückgegeben werden.

In diesem Abschnitt untersuchen wir, wie Daten, die von einer Abfrage zurückgegeben werden, mithilfe der ORDER BY-Klausel organisiert und priorisiert werden können. Diese Klausel wird am Ende einer SELECT-Anweisung platziert und ermöglicht es, die Ergebnisse nach einer oder mehreren Spalten entweder aufsteigend oder absteigend zu sortieren, was eine aussagekräftigere und leichter interpretierbare Datenausgabe ermöglicht.

In diesem Abschnitt lernen wir, wie man zurückgegebene Daten mit der WHERE-Klausel der SELECT-Anweisung filtert. Wir behandeln das Testen auf Gleichheit, Ungleichheit, Wertebereiche größer und kleiner sowie NULL-Werte.

In diesem Abschnitt untersuchen wir, wie Sie Ihre Suchbedingungen durch die Kombination von WHERE-Klauseln mit den Operatoren AND und OR verfeinern können. Außerdem behandeln wir, wie der NOT-Operator verwendet werden kann, um bestimmte Ergebnisse auszuschließen.

In diesem Abschnitt lernen wir, was SQL-Aggregatfunktionen sind und wie sie verwendet werden, um Tabellendaten zusammenzufassen.

Abrufen Aller Spalten

Lösung