Comment générer des données de test pour un algorithme "grouper par les données d'autres lignes"

Question

MISE À JOUR: Je cherche une technique pour calculer des données pour tous les cas de bord de mon algorithme (ou algorithme arbitraire d'ailleurs).
Ce que je essayé jusqu'à présent est juste penser à ce qui pourrait être des cas de pointe + produisant des données « au hasard », mais je ne sais pas comment je peux je ne être plus sûr de ne pas manquer les utilisateurs quelque chose de réel seront capables de chambouler ..

Je veux vérifier que je ne l'ai pas manqué quelque chose d'important dans mon algorithme et je ne sais pas comment générer des données de test pour toutes les situations possibles:

La tâche est-à- rapport des instantanés de données pour chaque Event_Date, mais faire une ligne distincte pour les modifications qui peuvent appartenir à la suivante Event_Date - voir Groupe 2) sur l'entrée et de sortie illustration:

Mon algorithme:

1. faire une liste des event_date s et calculer next_event_date s pour les
2. rejoindre les résultats main_audit_table et calculer le plus grand transaction_id pour chaque instantané (Groupes 1-4 dans mes illustra tion) - groupped par des id, event_date et par 2 options selon que transaction_date < next_event_date est vrai ou non
3. joindre main_audit_table aux résultats pour obtenir les autres données de la même transaction_id
4. joindre costs_audit_table aux résultats - utiliser le plus grand transaction_id qui est inférieure à transaction_id du résultat

Ma question (s):

• Comment puis-je générer des données de test qui couvrirait tous les scénarios possibles, donc je sais que je suis le droit d'algorithme?
• Pouvez-vous voir des erreurs dans ma logique de l'algorithme?
• Y at-il un meilleur forum pour ce genre de questions?

Mon Code (qui doit être testé):

select 
    snapshots.id, 
    snapshots.event_date, 
    main.event, 
    main.transaction_date as last_change, 
    costs.costs as costs_2012 
    from (
    --snapshots that return correct transaction ids grouped by event_date 
    select 
     main_grp.id, 
     main_grp.event_date, 
     max(main_grp.transaction_id) main_transaction_id, 
     max(costs_grp.transaction_id) costs_transaction_id 
    from main_audit_table main_grp 
    join (
     --list of all event_dates and their next_event_dates 
     select 
     id, 
     event_date, 
     coalesce(lead(event_date) over (partition by id order by event_date), 
       '1.1.2099') next_event_date 
     from main_audit_table 
     group by main_grp.id, main_grp.event_date 
    ) list on list.id = main_grp.id and list.event_date = main_grp.event_date 
    left join costs_audit_table costs_grp 
     on costs_grp.id = main_grp.id and 
     costs_grp.year = 2012 and 
     costs_grp.transaction_id <= main_grp.transaction_id 
    group by 
     main_grp.id, 
     main_grp.event_date, 
     case when main_grp.transaction_date < list.next_event_date 
      then 1 
      else 0 end 
) snapshots 
    join main_audit_table main 
    on main.id = snapshots.id and 
     main.transaction_id = snapshots.main_transaction_id 
    left join costs_audit_table costs 
    on costs.id = snapshots.id and 
     costs.transaction_id = snapshots.costs_transaction_id 

Answer 1

expressions de table commune (CTE) ne sont pas seulement un bon moyen d'enterrer la complexité et de réduire la duplication des plus extraits SQL, mais également un moyen facile de représenter les données de test comme si elles provenaient d'une table permanente. À tout le moins, les CTE concentreront les principaux composants de votre requête en haut, ce qui vous permettra de vous y référer par leur étiquette tout au long de la déclaration. Le DB2 SQL Cookbook de Graeme Birchall (un e-book gratuit et bien entretenu) a quelques bons exemples de ceci et d'autres modèles avancés de SQL. Joe Celko est une autre bonne source d'idées sur la façon de rendre SQL plus soulever des charges pour vous.