אימות אוטומטי של שלמות נתונים לאחר העברה

בדיקות שלמות נתונים אוטומטיות לאחר העברה

העברת נתונים היא תמיד מלחיצה. העברת אלפי רשומות, אבל האם אתה בטוח ששום דבר לא אבד? יחסים נשמרו? כתובות URL לא נשברו? ללא בדיקות אוטומטיות, אתה מנחש. בדיקה ידנית מדגמית היא הגרלה: אתה בודק 5% מהרשומות, אבל שגיאות מסתתרות ב-95% הנותרים. במיוחד עם תגובות מקוננות, שדות מטא, או תגי SEO — החמצה אחת יכולה לעלות בתנועה או בפונקציונליות.

לאחרונה עבדנו עם לקוח: 10,000 פוסטים, 50,000 תגובות שהועברו מ-WordPress ל-Laravel. בדיקה ידנית מדגמית (3 ימים, שני מהנדסים) מצאה 30 קישורים שבורים. בדיקות אוטומטיות — תוך יום אחד — חשפו 200 תגובות שאבדו, 5% כתובות URL כפולות, ו-150 עמודים ללא כותרות SEO. ההבדל ברור: אוטומציה מהירה פי 3 ומדויקת פי 20.

אנחנו צוות מהנדסים עם ניסיון של 5+ שנים בהעברות מורכבות. פיתחנו סט סקריפטים שנותן תמונה מלאה של שלמות הנתונים תוך 1–2 ימים. הסקריפטים מתאימים עצמם ל-CMS ולמבנה מסד הנתונים שלך — בין אם זה PostgreSQL, MySQL, או MongoDB.

למה בדיקות שלמות אוטומטיות הן חיוניות

בדיקה ידנית מדגמית אינה יעילה. אתה מסתכן באובדן של 2–5% מהרשומות (במיוחד תגובות מקוננות או שדות מטא), שבירת יחסי הורה-ילד, יצירת כתובות URL כפולות, והשארת תגי SEO חסרים — כל אלה פוגעים בדירוג. אוטומציה מבטלת סיכונים אלה. השווה בין שתי הגישות:

השלכות אופייניות של שגיאות שהוחמצו:

מה אנחנו בודקים: רשימת בדיקה מפורטת

המהנדסים שלנו יישמו סקריפטים לחמש בדיקות מפתח. כל אחת כוללת מדדים קונקרטיים.

איך פועלת בדיקת Checksum

אנחנו משווים MD5 מצטבר על שדות קריטיים. זה מזהה אפילו שינויים קלים בנתונים. מקור: ויקיפדיה, MD5.

def checksum_check(source_db, target_db):
    """Сравнение контрольных сумм по критичным полям"""
    # PostgreSQL
    source_hash = source_db.query_one("""
        SELECT md5(string_agg(
            md5(id::text || coalesce(email,'') || coalesce(slug,'')),
            ',' ORDER BY id
        )) as hash
        FROM articles
        WHERE status = 'published'
    """)
    target_hash = target_db.query_one("""
        SELECT md5(string_agg(
            md5(legacy_id || coalesce(email,'') || coalesce(slug,'')),
            ',' ORDER BY CAST(legacy_id AS INTEGER)
        )) as hash
        FROM articles
        WHERE status = 'published'
    """)
    return source_hash == target_hash

בדיקת ספירת רשומות

אנחנו משווים ספירות רשומות לפי סוג תוכן, תוך התחשבות במסנני סטטוס (פורסם/טיוטה). קוד לדוגמה:

class MigrationValidator:
    def __init__(self, source_db, target_db):
        self.source = source_db
        self.target = target_db
        self.results = []

    def check_counts(self):
        tables = [
            ('posts', 'articles', "status='publish'", "status='published'"),
            ('users', 'users', None, None),
            ('comments', 'comments', "approved=1", "status='approved'"),
            ('categories', 'categories', None, None),
        ]
        for src_table, tgt_table, src_where, tgt_where in tables:
            src_count = self.source.count(src_table, src_where)
            tgt_count = self.target.count(tgt_table, tgt_where)
            status = 'OK' if src_count == tgt_count else 'MISMATCH'
            self.results.append({
                'check': f'count_{src_table}',
                'status': status,
                'source': src_count,
                'target': tgt_count,
                'diff': tgt_count - src_count
            })

בדיקת שלמות הפניות

אנחנו מחפשים רשומות יתומות: מאמרים ללא מחבר, תגובות ללא מאמר הורה או תגובה הורה.

def check_referential_integrity(target_db):
    issues = []
    # Статьи без автора
    orphaned_posts = target_db.query("""
        SELECT a.id, a.title
        FROM articles a
        LEFT JOIN users u ON a.author_id = u.id
        WHERE a.author_id IS NOT NULL AND u.id IS NULL
    """)
    if orphaned_posts:
        issues.append(f"Articles without valid author: {len(orphaned_posts)}")

    # Комментарии к несуществующим постам
    orphaned_comments = target_db.query("""
        SELECT c.id
        FROM comments c
        LEFT JOIN articles a ON c.post_id = a.id
        WHERE a.id IS NULL
    """)
    if orphaned_comments:
        issues.append(f"Orphaned comments: {len(orphaned_comments)}")

    # Дочерние комментарии без родителя
    broken_threads = target_db.query("""
        SELECT c.id
        FROM comments c
        LEFT JOIN comments p ON c.parent_id = p.id
        WHERE c.parent_id IS NOT NULL AND p.id IS NULL
    """)
    if broken_threads:
        issues.append(f"Comments with missing parent: {len(broken_threads)}")

    return issues

בדיקת זמינות כתובות URL

אנחנו בודקים באופן אסינכרוני כל כתובת URL שפורסמה עבור HTTP 200, 404, 500, ושרשראות הפניות.

import asyncio
import aiohttp

async def check_urls(urls, base_url, concurrency=20):
    errors = {'404': [], '500': [], 'redirect_chain': []}
    semaphore = asyncio.Semaphore(concurrency)

    async def check_one(session, path):
        async with semaphore:
            url = f"{base_url}{path}"
            try:
                async with session.get(url, allow_redirects=True) as resp:
                    if resp.status == 404:
                        errors['404'].append(path)
                    elif resp.status >= 500:
                        errors['500'].append(path)
                    elif len(resp.history) > 2:
                        errors['redirect_chain'].append(f"{path} ({len(resp.history)} redirects)")
            except Exception as e:
                errors['500'].append(f"{path} (error: {e})")

    async with aiohttp.ClientSession() as session:
        tasks = [check_one(session, url) for url in urls]
        await asyncio.gather(*tasks)
    return errors

# Запуск
urls_to_check = get_all_published_urls(target_db)
results = asyncio.run(check_urls(urls_to_check, 'https://new-site.com'))

בדיקת מטא נתוני SEO

אנחנו מחפשים עמודים חסרי כותרת/תיאור, כותרות כפולות, ותגי canonical חסרים.

def check_seo_completeness(target_db):
    issues = []

    # Страницы без title
    no_title = target_db.query("""
        SELECT slug
        FROM articles
        WHERE (seo_title IS NULL OR seo_title = '') AND status = 'published'
    """)
    if no_title:
        issues.append(f"Pages without SEO title: {len(no_title)}")

    # Страницы без meta description
    no_desc = target_db.query("""
        SELECT slug
        FROM articles
        WHERE (seo_description IS NULL OR seo_description = '') AND status = 'published'
    """)
    if no_desc:
        issues.append(f"Pages without meta description: {len(no_desc)}")

    # Дублирующиеся title
    dup_titles = target_db.query("""
        SELECT seo_title, COUNT(*) as count
        FROM articles
        WHERE status = 'published'
        GROUP BY seo_title
        HAVING COUNT(*) > 1
    """)
    if dup_titles:
        issues.append(f"Duplicate SEO titles: {len(dup_titles)} groups")

    return issues

התהליך שלנו

1. ניתוח סכמה — לימוד מבני מסדי הנתונים של המקור והיעד, זיהוי טבלאות ושדות קריטיים.
2. התאמת סקריפטים — התאמת בדיקות לסטACK הספציפי שלך (PostgreSQL/MySQL, CMS).
3. ריצה ואיסוף תוצאות — הרצת סקריפטים, הפקת דוח ב-HTML/JSON/JUnit.
4. ניתוח והמלצות — פירוט כל בדיקה שנכשלה, הצעת תוכנית תיקון.
5. פריסת CI/CD (אופציונלי) — אריזת בדיקות לקונטיינר Docker, חיבור לצינור.

מה כלול

• סקריפטי בדיקה (Python, ניתנים להגדרה לפרויקט שלך).
• דוח מפורט עם טבלת תוצאות ורשימת רשומות בעייתיות.
• המלצות תיקון לכל שגיאה.
• תיעוד על הרצה ופרשנות תוצאות.
• הדרכה למהנדס אחד מטעם הלקוח.
• אחריות: אם לאחר תיקונים נמצא אי-התאמה, נחדד את הסקריפט ללא עלות נוספת.

לוח זמנים משוער

פיתוח סקריפטים ודוח סופי: 1–2 ימי עבודה. המורכבות תלויה במספר הטבלאות ובנפח הנתונים. העלות מחושבת באופן אישי — צור קשר לקבלת הערכה מדויקת.

למה לבחור בנו

• 5+ שנות העברות: מ-WordPress לפתרונות Laravel מותאמים אישית.
• 200+ פרויקטי העברת נתונים.
• מהנדסים מוסמכים ב-PostgreSQL ו-Docker.
• אחריות לתוצאה: כל הבדיקות רצות בסביבת בדיקה לפני הביצוע הראשי.

בקש ייעוץ על שלמות נתונים לאחר העברה — נעריך את ההיקף ונמליץ על סט הבדיקות האופטימלי. צור קשר כדי לקבל תוכנית עבודה מפורטת והערכת עלות.