Как проверить, что в SQL таблице есть данные?

Как проверить, что в SQL таблице есть данные

Проверка наличия данных в таблице требуется при миграциях, инициализации БД и диагностике. Рассмотрю различные подходы.

Способ 1: COUNT(*) — простейший способ

-- Проверка: есть ли вообще данные
SELECT COUNT(*) as total FROM users;

-- Результат: 0 (пусто) или число > 0 (есть данные)

Python с psycopg2:

import psycopg2

conn = psycopg2.connect("dbname=mydb user=postgres")
cur = conn.cursor()

-- Проверка наличия данных
cur.execute("SELECT COUNT(*) FROM users")
count = cur.fetchone()[0]

if count > 0:
    print(f"В таблице {count} записей")
else:
    print("Таблица пуста")

cur.close()
conn.close()

SQLAlchemy:

from sqlalchemy import func, select
from sqlalchemy.orm import Session

def has_data(session: Session, model) -> bool:
    count = session.query(func.count(model.id)).scalar()
    return count > 0

# Использование
from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)
session = Session()

if has_data(session, User):
    print("В таблице есть пользователи")
else:
    print("Таблица пуста")

Способ 2: EXISTS — оптимальнее для больших таблиц

-- EXISTS более эффективен для больших таблиц
SELECT EXISTS(SELECT 1 FROM users LIMIT 1) as has_data;

-- Результат: t (true) или f (false)

Что происходит:

• COUNT(*) — пересчитывает ВСЕ строки
• EXISTS — останавливается на первой найденной строке

Python:

from sqlalchemy import exists, select

def table_has_data(session: Session, model) -> bool:
    stmt = select(exists(select(1).select_from(model)))
    return session.execute(stmt).scalar()

-- Использование
if table_has_data(session, User):
    print("Данные присутствуют")

Способ 3: LIMIT 1 — для простых проверок

-- Просто получаем одну строку
SELECT 1 FROM users LIMIT 1;

-- Если результат пуст — таблица пуста
-- Если есть результат — таблица содержит данные

Python:

from sqlalchemy import select

def has_records(session: Session, model) -> bool:
    result = session.execute(
        select(model).limit(1)
    ).scalars().first()
    return result is not None

-- Использование
if has_records(session, User):
    print("Есть данные")

Способ 4: Проверка с условиями

-- Есть ли активные пользователи?
SELECT COUNT(*) FROM users WHERE is_active = true;

-- Или через EXISTS
SELECT EXISTS(
    SELECT 1 FROM users WHERE is_active = true LIMIT 1
) as has_active_users;

Python:

from sqlalchemy import select, func

def has_active_users(session: Session) -> bool:
    count = session.query(func.count(User.id)).filter(
        User.is_active == True
    ).scalar()
    return count > 0

-- Или более читаемо
def has_active_users_v2(session: Session) -> bool:
    result = session.execute(
        select(User).where(User.is_active == True).limit(1)
    ).scalars().first()
    return result is not None

Способ 5: Проверка в миграциях (Goose)

-- migration: 0001_check_and_migrate.sql

-- Проверяем есть ли данные
DO $$
BEGIN
    IF EXISTS(SELECT 1 FROM users LIMIT 1) THEN
        -- Данные есть, делаем что-то
        UPDATE users SET updated_at = NOW();
    ELSE
        -- Данные отсутствуют, инициализируем
        INSERT INTO users (name, email) VALUES ('Admin', 'admin@example.com');
    END IF;
END $$;

Способ 6: Проверка в Python приложении

from sqlalchemy import inspect

def table_exists_and_has_data(engine, table_name: str) -> bool:
    inspector = inspect(engine)
    
    -- Проверка 1: таблица существует
    if table_name not in inspector.get_table_names():
        return False
    
    -- Проверка 2: таблица содержит данные
    with engine.connect() as conn:
        result = conn.execute(f"SELECT COUNT(*) FROM {table_name}")
        count = result.scalar()
        return count > 0

-- Использование
if table_exists_and_has_data(engine, "users"):
    print("Таблица users готова")
else:
    print("Нужна инициализация БД")

Способ 7: Статистика таблицы

-- PostgreSQL: информация о размере таблицы
SELECT 
    schemaname,
    tablename,
    pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as size,
    n_live_tup as row_count
FROM pg_stat_user_tables
WHERE tablename = 'users';

-- Если n_live_tup > 0 — есть данные

Способ 8: Для проверки нескольких таблиц

from typing import Dict

def check_all_tables(session: Session, models: list) -> Dict[str, bool]:
    results = {}
    
    for model in models:
        count = session.query(func.count(model.id)).scalar()
        results[model.__tablename__] = count > 0
    
    return results

-- Использование
from app.models import User, Post, Comment

status = check_all_tables(session, [User, Post, Comment])
print(status)
-- {'users': True, 'posts': False, 'comments': False}

Способ 9: Seed данные если пусто

from sqlalchemy.orm import Session

def init_database_if_empty(session: Session):
    user_count = session.query(func.count(User.id)).scalar()
    
    if user_count == 0:
        print("Инициализирую БД...")
        
        admin = User(name="Admin", email="admin@example.com")
        user = User(name="User", email="user@example.com")
        
        session.add_all([admin, user])
        session.commit()
        
        print(f"Добавлено {session.query(func.count(User.id)).scalar()} пользователей")
    else:
        print(f"БД уже содержит {user_count} пользователей")

-- Использование при старте приложения
if __name__ == "__main__":
    from app.database import get_session
    
    session = get_session()
    init_database_if_empty(session)

Способ 10: Алерт на пустоту

import logging
from datetime import datetime

logger = logging.getLogger(__name__)

def check_critical_tables(session: Session):
    critical_tables = {
        User: "Пользователи",
        Product: "Товары",
        Order: "Заказы"
    }
    
    for model, name in critical_tables.items():
        count = session.query(func.count(model.id)).scalar()
        
        if count == 0:
            logger.error(f"ALERT: Таблица '{name}' пуста!")
        elif count < 10:
            logger.warning(f"LOW DATA: Таблица '{name}' содержит только {count} записей")

Сравнение методов

Лучшие практики

• Используйте EXISTS или LIMIT 1 для быстрой проверки
• Используйте COUNT только когда нужно число
• Логируйте инициализацию БД при старте
• Мониторьте пустые таблицы в production
• Кэшируйте результаты проверки
• Не проверяйте каждый запрос — один раз при старте достаточно