Je travaille actuellement avec DBS dans le flocon de neige et j'ai un problème de performance.
Dans ma requête, j'ai besoin de récupérer 100 rangées de données à partir d'une carte principale qui contient des clés étrangères à d'autres tables. La taille principale_table est comprise entre 50k-300K lignes.
Cette carte principale contient des identifiants (touches étrangères) du numéro de type (38,0) et la description de ces champs / colonnes est extraite des autres tables avec un intérieur simple Rejoindre.
Les tables secondaires (Table_One, Table_Two ...) sont très petites, toutes ont moins de 20 rangées, sauf une, qui a environ 1500 rangées (encore très petites)
Le problème est : exécution de la requête, comme indiqué ci-dessous, prend en moyenne 1,7 à compléter.
Si je supprime tous les champs de descendance (récupérés à l'aide de jointures intérieures), et toutes les jonctions intérieures, la requête prend en moyenne 300 ms à compléter. Ils ont mis en cache les informations de toutes les tables secondaires de notre application (fabriquées en Java, mais cela n'est pas pertinent ). Pour environ 80% des cas (voir la requête ci-dessous), que nous n'avons pas besoin de filtrer par description, cela fonctionne, mais sur les 20% des cas, nous devons encore effectuer les jointures intérieures. Diminués de la solution : n'est pas une mauvaise solution, mais il a deux problèmes: Une possibilité qui me vient à l'esprit est la mise en cache de ces tables en SF, mais je n'ai pas encore trouvé de manière simple de le faire. Peut-être qu'il y a un moyen d'optimiser la requête, mais je ne comprends pas encore à quel point le flocon de neige fonctionne en interne, autant que je sache, cela n'utilise pas d'index, du moins pas de la même manière que d'autres plates-formes. Ainsi, existe-t-il un moyen d'optimiser la requête en SF pour 100% des cas? petite mise à jour: J'ai essayé d'utiliser avec clauses, les deux enveloppant les identifiants et la description, mais il ne semble pas y avoir une amélioration
3 Réponses :
Je suis juste curieux si cela ferait une différence si vous avez formé la requête avec le filtrage sur la table principale des sous-requêtes:
FROM (SELECT *
FROM main_table
WHERE main_table.ONE_ID IN (25, 26) AND
main_table.TWO_ID IN (10, 12) AND
main_table.THREE_ID IN (1, 2, 3) AND
main_table.FOUR_ID IN (2, 3) AND
main_table.FIVE_ID IN (3) AND
main_table.SEVEN_ID IN (1)
) main_table JOIN
. . .
J'ai essayé, mais il ne semble pas améliorer la performance, je reçois des résultats très similaires comme avec la requête que j'ai postée comme exemple
@Davidalberici. .. Essayez d'ajouter les jointures une à la fois. Voir si une jointure particulière est un problème ou si la vitesse ralentit progressivement.
Avez-vous par hasard essayé de redéfinir vos tables de dictionnaire? Comme dans vous avez un:
Et vous pouvez essayer de le faire dans
Cette fois au lieu de 5 petites tables, vous aurez 1 conditions de jointure légèrement plus grandes et un peu plus complexes, car vous devrez ajouter un ID de dictionnaire à chacun d'eux, mais toutes les personnes vont probablement être récupérables dans un seul bloc de données au lieu de 5 blocs
Mon premier si, le flocon de neige n'est pas conçu pour poser des requêtes minuscules comme celle-ci rapidement, elle a fait pour répondre à de grandes requêtes. Ainsi pour moi 1.xs est un bon temps de réponse.
mais donné que vous voudriez que cela soit plus rapide.
Je vérifierais d'abord si le temps de compilation de la requête lente est identique à celui du rapide. Parce que si vos tables sont fragmentées, plus de données de méta devront être lues.
Ensuite, je regarderais le profil de l'exécution, pour voir où le temps est dépensé. Dans le passé, nous avons trouvé des choses comme être plus rapide que OH énormes déclarations SQL Nous avons trouvé Gordon's point de mise en place explicitement où les clauses au moment de la sélection d'une table aide à l'endroit où l'optimiseur est confus. mais un autre aspect peut simplement être les données supplémentaires prend plus de temps à vous transmettre au client (si vous êtes Utilisation du temps du client en tant que juge) ou si vous examinez les performances dans WebUI, plus les données que vous avez lues sur la plus longue nécessaire pour exécuter la requête. Donc, même si vous construisez une nouvelle table , puis prendra plus de temps que: et enfin, je sais que c'est l'exemple de code, mais il y a peu de point d'aliasing une table de Main_table à Main_table alias / nom déjà en place.
Lorsque vous exécutez ces tests, voyez-vous beaucoup de cache utilisé? Quelle est la taillée de chaque table dans le profil de la requête? Avez-vous essayé de créer une nouvelle table avec les champs de Descs dans le fait et comparé cela, aussi?
Avez-vous examiné le profil de requête pour voir ce qui prend le plus de temps? Vous êtes probablement sur la bonne voie en utilisant un CTE et devriez commencer par sortir les petites tables / jointures avec de longs processus dans le profil dans leurs propres sections du CTE.