diff --git a/check_db.py b/check_db.py
index c47c90d..71fb0b7 100644
--- a/check_db.py
+++ b/check_db.py
@@ -1,94 +1,77 @@
 #!/usr/bin/env python3
-import json
-from datetime import datetime
+import sqlite3
+import sys
 
-from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, ForeignKey, Text
-from sqlalchemy.orm import declarative_base, relationship, sessionmaker
+def list_tables(conn):
+    """Gibt eine Liste aller Tabellennamen in der Datenbank zurück."""
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+    tables = [row[0] for row in cursor.fetchall()]
+    return tables
 
-# Basis-Klasse (SQLAlchemy 2.0-konform)
-Base = declarative_base()
+def count_entries(conn, table_name):
+    """Gibt die Anzahl der Einträge in der angegebenen Tabelle zurück."""
+    cursor = conn.cursor()
+    try:
+        cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+        count = cursor.fetchone()[0]
+    except Exception as e:
+        count = None
+        print(f"Fehler beim Zählen der Einträge in {table_name}: {e}")
+    return count
 
-class Bundle(Base):
-    __tablename__ = 'bundles'
-    id = Column(Integer, primary_key=True)
-    machine_name = Column(String, unique=True)
-    human_name = Column(String)
-    current_version_id = Column(Integer, ForeignKey('bundle_versions.id'))
-    
-    # Beziehung zur aktuellen Version (explizit mit foreign_keys für current_version_id)
-    current_version = relationship("BundleVersion", uselist=False, foreign_keys=[current_version_id])
-    # Alle Versionen – hier verwenden wir einen lambda-Ausdruck, um die Spalte BundleVersion.bundle_id zu referenzieren
-    versions = relationship("BundleVersion", back_populates="bundle", foreign_keys=lambda: [BundleVersion.bundle_id])
-    # Verkaufshistorie
-    sales_history = relationship("BundleSalesHistory", back_populates="bundle")
-
-class BundleVersion(Base):
-    __tablename__ = 'bundle_versions'
-    id = Column(Integer, primary_key=True)
-    bundle_id = Column(Integer, ForeignKey('bundles.id'))
-    version_hash = Column(String)
-    version_data = Column(Text)    # Als JSON-String
-    timestamp = Column(DateTime, default=datetime.utcnow)
-    
-    # Hier geben wir explizit an, dass für diese Beziehung die Spalte bundle_id verwendet wird
-    bundle = relationship("Bundle", back_populates="versions", foreign_keys=[bundle_id])
-
-class BundleSalesHistory(Base):
-    __tablename__ = 'bundle_sales_history'
-    id = Column(Integer, primary_key=True)
-    bundle_id = Column(Integer, ForeignKey('bundles.id'))
-    bundles_sold = Column(Float)
-    timestamp = Column(DateTime, default=datetime.utcnow)
-    
-    bundle = relationship("Bundle", back_populates="sales_history")
-
-def main():
-    # Verbindung zur bereits vorhandenen SQLite-Datenbank
-    engine = create_engine('sqlite:///bundles.db')
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    
-    # Alle Bundles aus der Tabelle 'bundles' abfragen
-    bundles = session.query(Bundle).all()
-    if not bundles:
-        print("Die Datenbank enthält noch keine Bundles.")
+def print_table_contents(conn, table_name):
+    """Gibt den kompletten Inhalt der angegebenen Tabelle aus."""
+    cursor = conn.cursor()
+    try:
+        cursor.execute(f"SELECT * FROM {table_name}")
+    except Exception as e:
+        print(f"Fehler beim Abrufen der Inhalte von {table_name}: {e}")
         return
 
-    for bundle in bundles:
-        print("---------------------------------------------------")
-        print(f"Bundle-ID: {bundle.id}")
-        print(f"Machine Name: {bundle.machine_name}")
-        print(f"Human Name: {bundle.human_name}")
-        
-        if bundle.current_version:
-            print(f"Aktuelle Version (ID): {bundle.current_version.id}")
-            print(f"Version Hash: {bundle.current_version.version_hash}")
-            try:
-                version_info = json.loads(bundle.current_version.version_data)
-                # Hier geben wir nur einen gekürzten Ausschnitt der Version-Daten aus
-                version_str = json.dumps(version_info, indent=2)[:300]
-                print("Version-Daten (gekürzt):")
-                print(version_str + " ...")
-            except Exception:
-                print("Version-Daten (roher Text):")
-                print(bundle.current_version.version_data)
-            print(f"Letzte Aktualisierung: {bundle.current_version.timestamp}")
-        else:
-            print("Keine aktuelle Version hinterlegt.")
-        
-        # Alle historischen Versionen ausgeben
-        print("\nHistorische Versionen:")
-        for version in bundle.versions:
-            print(f"  Version-ID: {version.id}, Timestamp: {version.timestamp}, Hash: {version.version_hash}")
-        
-        # Verkaufszahlen ausgeben
-        print("\nVerkaufshistorie:")
-        if bundle.sales_history:
-            for sale in bundle.sales_history:
-                print(f"  {sale.timestamp}: {sale.bundles_sold} verkauft")
-        else:
-            print("  Keine Verkaufsdaten vorhanden.")
-    print("---------------------------------------------------")
+    # Spaltennamen abrufen
+    column_names = [desc[0] for desc in cursor.description]
+    print("Spalten:", column_names)
+    rows = cursor.fetchall()
+    for row in rows:
+        print(row)
+
+def main():
+    # Parameter auswerten:
+    # Standard: Nur Tabellenliste mit Eintragszahl
+    # Wenn "detail" angegeben wurde, sollen auch die Inhalte ausgegeben werden.
+    # Wird "detail <tablename>" angegeben, dann nur für die angegebene Tabelle.
+    detail = False
+    specific_table = None
+
+    if len(sys.argv) > 1:
+        if sys.argv[1].lower() == "detail":
+            detail = True
+            if len(sys.argv) > 2:
+                specific_table = sys.argv[2]
+
+    # Verbindung zur Datenbank herstellen
+    conn = sqlite3.connect("bundles.db")
+    
+    tables = list_tables(conn)
+    if not tables:
+        print("Die Datenbank enthält keine Tabellen.")
+        return
+
+    print("Tabellen in der Datenbank:")
+    for table in tables:
+        # Falls ein spezifischer Tabellename angegeben wurde, überspringe alle anderen
+        if specific_table and table.lower() != specific_table.lower():
+            continue
+        count = count_entries(conn, table)
+        count_str = f"{count} Einträge" if count is not None else "unbekannte Einträge"
+        print(f" - {table}: {count_str}")
+        if detail:
+            print(f"   Inhalt der Tabelle {table}:")
+            print_table_contents(conn, table)
+            print("-" * 40)
+    
+    conn.close()
 
 if __name__ == "__main__":
     main()