Transcription
1. Intro: Salut, Max est là.
Bienvenue dans ta mission SQL. Dans cette mission,
vous allez
apprendre à utiliser le SQL pour traiter analyser des données directement dans la base de données à l'
aide de requêtes SQL. À la fin de cette mission,
vous serez capable d'
écrire des requêtes SQL
qui ressemblent à ceci, et vous apprendrez également ce que sont les bases de données
relationnelles Tout au long du cours,
vous allez d'abord commencer par votre configuration. Ensuite, vous allez
aborder quelques notions de base sur les tables, les bases de données et les requêtes. Tu vas apprendre l'
arithmétique. Vous allez en
apprendre davantage sur les dates et les heures, sur la manipulation des données, puis vous allez
également aborder sujets
plus complexes tels que les jointures, unions et les fonctions de fenêtre J'ai donc hâte
que vous commenciez.
2. Introduction aux bases de données relationnelle: Hé là, x max et bienvenue. Donc, dans cette leçon, nous allons apprendre sur bases de données
relationnelles juste pour nous assurer que tout le monde est au même niveau, que tout le monde a les mêmes connaissances
sur les bases de données relationnelles et que nous sommes tous familiers avec les termes clés de sorte que lorsque nous commençons réellement à utiliser SQL et à apprendre SQL, lorsque vous entendez l'un des termes nécessaires, vous comprenez exactement de quoi je parle. Donc, tout d'abord, les bases de données
relationnelles ou relationnelles dans un modèle relationnel sont divisées en tables. Donc, une base de données va être composée de plusieurs tables, mais commençons par la table. Donc, par exemple, nous pouvons avoir une table comme nous le voyons sur la droite ici. La première chose que nous remarquons est que la table a un nom, que vous pouvez voir au-dessus. Maintenant, c'est comme ça que je vais le montrer. Habituellement, le nom va être représenté ailleurs. Mais juste pour s'assurer que tout est lié ici, nous aurons le nom sur le dessus. Donc, dans ce cas, notre nom est soulignement utilisateur et téléphone. Maintenant, vous remarquerez quelque chose sur le nommage, qui est là pour les conventions de nommage générales. L' un d'eux utilise un trait de soulignement et l'autre utilise des lettres majuscules. Vous pouvez voir l'exemple en majuscules dans l'ID utilisateur, qui est une colonne dans notre tableau d'informations utilisateur. Ces deux options sont juste des conventions de dénomination différentes et elles sont là juste pour vous aider, l'utilisateur ou peut-être aussi
l' administrateur de base de données ou toute autre personne qui a besoin d'utiliser cette base de données, être en mesure de tout lire plus facile, car il est beaucoup plus facile de lire des mots séparés par un trait de soulignement ou des mots où chaque nouveau mot commence par une majuscule. Et il est beaucoup plus facile de lire des mots comme ça où tout est minuscules
ou en majuscules ou quelque chose comme ça. Et donc vous verrez probablement l'une de ces deux conventions d'attribution de noms est utilisée lorsque vous utilisez une base de données SQL, par
exemple, dans une entreprise, ou lorsque vous en obtenez une dans une interview technique ou quelque chose comme ça. Maintenant, comme vous l'avez probablement remarqué et le savez probablement déjà, les
tables sont faites à partir de lignes et de colonnes et c'est de la même manière dans une base de données relationnelle. Donc, nous pouvons voir ici notre table, la table userinfo a quatre colonnes différentes appelées l'ID utilisateur, un
autre appelé nom, un
autre appelé jointure, et un autre appelé email. Et il a également différentes rangées. On peut voir ici que nous avons trois rangées dans cette affaire. On en parlera plus dans une seconde. Mais oui, ça va être le genre de structure de base que notre base de données est composée de différentes tables. Chaque table a un nom, et chaque table est également composée de colonnes et de lignes. Maintenant, chaque table d'une base de données relationnelle a également quelque chose appelé une clé primaire. La clé primaire est la colonne qui identifie de manière unique chaque ligne. Donc, nous pouvons voir ici, dans ce cas, notre clé primaire va être l'ID utilisateur, ce qui signifie que chaque ligne doit avoir un ID utilisateur unique. Cette clé primaire peut apparaître naturellement. Par exemple, dans notre tableau userinfo, l'ID utilisateur sera unique par conception, car chaque utilisateur aura un ID unique. Et donc l'ID utilisateur est une excellente colonne à utiliser comme clé primaire. Mais dans d'autres cas, la clé primaire peut être une colonne supplémentaire car il n'y a pas de colonne dans notre tableau qui ne donne pas vraiment lieu à un essai sans identification unique. De toute façon, une clé primaire dans les tables importante parce que c'est ce qui va nous
permettre d'identifier chaque enregistrement de notre base de données individuellement. Et il est donc important que nous ayons une colonne pour la clé primaire, car de cette façon nous pouvons avoir un identifiant unique pour chaque ligne que nous avons dans notre table. Quelque chose d'autre qui est important est la clé primaire. Il ne peut y en avoir qu'une par table. Vous ne pouvez pas avoir deux clés primaires dans une table. Donc, la clé primaire ne sera qu'une, et cela va également nous permettre d'identifier de manière unique chaque ligne. Maintenant, nous utilisons les termes ligne et colonnes. Mais en fait, en SQL, généralement les colonnes vont être appelées attributs et les lignes vont être appelées enregistrements. Et donc vous pouvez penser que les colonnes sont des attributs de chacun de nos enregistrements. Encore une fois, les enregistrements étant des lignes. Ainsi, par exemple, si nous regardons la première ligne ou le premier enregistrement, nous avons l'UserId 1. Donc, l'attribut de notre première ligne où il a un ID utilisateur de un et nom. Alice a rejoint le 11 mai et un email a à abc.com. Donc, cela va être une sorte de la syntaxe que vous allez probablement entendre lorsque vous regardez des tables et que vous savez, entendre parler des lignes et des colonnes ou plutôt des enregistrements et des attributs. Maintenant, comme je l'ai mentionné plus tôt, généralement une base de données va avoir plusieurs tables plutôt qu'une seule. Ainsi, par exemple, notre base de données me, il peut être sur les utilisateurs et le stockage informations
utilisateur ainsi que des informations sur les événements que les utilisateurs font. Et donc nous avons pu voir des tables, par
exemple, appelées UserInfo, que nous avions auparavant, qui nous pourrions aussi avoir une autre table appelée le journal des événements. Et nous pouvons avoir une autre table appelée Event Info. Et ces tables vont toutes être liées d'une manière ou d'une autre. Habituellement, la meilleure façon de définir
ces relations n' est pas par quelque chose qu'on appelle une clé étrangère. Ainsi, par exemple, dans notre journal des événements, nous avons deux clés étrangères. Et avec les clés étrangères sont, est, sont des colonnes de cette table qui fait référence à la clé primaire dans une autre table. Par exemple, jetons un coup d'oeil à la table du journal des événements. Ici, nous avons deux clés étrangères. L' un d'eux sera l'ID utilisateur. Maintenant, l'ID utilisateur fait référence à la colonne ID et à la table userinfo. Et nous avons une autre clé étrangère ici appelée l'ID d'événement. Maintenant, l'ID d'événement va référencer la colonne ID dans la table d'informations d'événement. De cette façon, nous pouvons également structurer les relations entre nos différentes tables. Dans le cas contraire, il serait inefficace pour nous de
stocker toutes ces données dans la même table. Et c'est pourquoi nous divisons ces tables, ou c'est pourquoi nous divisons les données plutôt en ces différentes tables. Parce que sinon nous aurions une très grande table. Parce que imaginez si nous avons notre journal d'événements et pour chaque événement, nous stockons également toutes les informations sur l'utilisateur ainsi que les informations sur l'événement lui-même. Cela signifie que chaque enregistrement aura beaucoup de doublons parce que les informations de
l'utilisateur ne vont pas changer et les informations sur l'événement ne vont pas changer. Et donc, une meilleure façon de structurer cela est de garder la tête
du journal des événements et tout ce qui a besoin qui n'est pas pertinent pour ce journal des événements qui va changer. Et les informations, par exemple, sur l'utilisateur, peuvent être stockées dans la table userinfo. Et tout ce dont nous avons besoin dans le journal des événements, c'est qui a fait l'événement. Mais si vous voulez en savoir plus sur l'utilisateur, alors nous pouvons avoir notre clé étrangère, l'ID utilisateur dans la table du journal des événements, qui fait référence à la clé primaire, l'ID et la table d'informations utilisateur. Et donc, nous pouvons obtenir une recherche directe essentiellement. Et pour chaque enregistrement, si nous le voulons, alors nous pouvons obtenir plus d'informations sur l'utilisateur et ensuite la même chose sur les événements. Ainsi, nous pouvons utiliser des clés étrangères pour faire des références entre les tables et les lier ensemble. Maintenant, nous avons parlé de la clé primaire, en mettant une retenue sur chaque table, qui signifie que la valeur et la clé primaire doivent être uniques sur chaque ligne, doivent être uniques sur chaque enregistrement. Mais vous pouvez également avoir des contraintes supplémentaires. Par exemple, une autre contrainte que nous pouvons vouloir faire est que nous voulons dire OK, le champ email dans la table userinfo doit également être unique. Maintenant, il ne va pas identifier de manière unique la personne, mais nous voulons qu'elle soit unique pour chaque personne. Ainsi, nous pouvons avoir une clé primaire, par
exemple, étant l'ID utilisateur. Et puis nous avons un autre champ, par
exemple, l'e-mail. Mais nous voulons également nous assurer que la colonne e-mail elle-même est unique. Et nous pouvons donc mettre des contraintes supplémentaires sur une table
pour dire, par exemple, que l'e-mail doit être unique. Ou peut-être si vous avez une plate-forme différente où vous pouvez vous connecter sur différentes régions et que vous avez un nom et que vous avez différentes régions, alors vous pouvez dire que le nom ou le nom d'utilisateur qu'une personne veut utiliser doit être unique dans chaque région. Ainsi, vous pouvez avoir une combinaison du nom et la combinaison de la région doit être unique. Ainsi, les gens peuvent avoir le même nom d'utilisateur dans différentes régions. Mais dans chaque région, chaque personne n'a le droit d'avoir qu'un seul nom d'utilisateur. Par exemple, les noms d'utilisateur ne peuvent apparaître qu'une seule fois. De cette façon, vous pouvez avoir des contraintes supplémentaires aux tables qui vont au-delà la clé primaire qui nécessitent également l'unicité ou qui entraînent également l'ajout de conditions sur la table. Maintenant, cela ne va pas remplacer la clé primaire, mais ce sera des contraintes supplémentaires en plus de la contrainte dont nous avons besoin pour avoir la clé primaire, que chaque valeur de la clé primaire doit être unique dans chaque enregistrement unique. Ces contraintes peuvent bien sûr être bonnes parce que de cette façon, si vous MRF, quelqu'un d'autre veut peut-être créer un compte, mais les e-mails ont déjà été utilisés pour quelque raison que ce soit. Et nous pouvons leur envoyer un message d'erreur et dire que les e-mails sont déjà utilisés. Et nous ne créerons pas d'enregistrements où plusieurs personnes ont le même e-mail. Parce que si vous voulez envoyer un e-mail à nos utilisateurs, par exemple, dans plusieurs personnes différentes utilisent le même e-mail pour une raison quelconque, et cela va évidemment causer des problèmes. Et donc s'il y a des contraintes supplémentaires, comme combien, soit par la logique métier ou simplement par votre compréhension de la façon dont toutes ces données doivent être organisées, alors vous pouvez bien sûr les mettre dans ou cela plutôt que ces contraintes peuvent être mises sur les tables individuelles de sorte que, vous savez, aucun de ces problèmes ne se produise. Maintenant, au fil du temps, même si nous sommes en train de diviser nos données en ces différentes tables, sont les tables peuvent toujours devenir très grandes. Par exemple, notre journal des événements peut croître très rapidement si nous avons beaucoup d'utilisateurs utilisant notre plateforme. Et donc quelque chose dont vous pouvez entendre parler est quelque chose appelé une partition. Maintenant, une partition comme un moyen de diviser une table en sous-morceaux plus petits. Et de cette façon, nous pouvons les stocker dans différents endroits. Et cela peut rendre le stockage plus efficace, mais cela peut également rendre l'interrogation plus efficace. Habituellement, vous faites une partition par une colonne qui est souvent utilisée pour le filtrage. Ainsi, par exemple, une façon très courante de partitionner les données est par date. Parce que souvent, si vous faites une requête, par exemple, vous voulez voir tous les utilisateurs actifs au cours de la dernière semaine, alors vous allez interroger ou plutôt vous allez filtrer par date. Donc, si votre table est partitionnée ou plutôt divisée en différents segments, vous n'avez pas besoin de passer par autant de données. Il suffit de référencer les tables qui contiennent réellement les données appropriées. De cette façon, il sera plus efficace pour le stockage parce que vous n'avez pas besoin de stocker une grande table en un seul endroit. Mais il va également être plus efficace pour interroger parce que vous avez seulement besoin de
passer par une plus petite partie de la table pour obtenir les résultats que vous recherchez. Maintenant, la chose cool à propos des partitions est. Ne vous affectez pas vraiment car la requête ou les partitions sont prises en charge par la base de données elle-même. Et il gérera toutes ces choses de stockage pour vous. Et cela le rendra plus efficace si vous filtrez par les colonnes qui sont utilisées pour les partitions. Mais si vous voulez obtenir toutes les données sur la table, vous pouvez toujours, même si la table va être partitionnée, vous pouvez toujours interroger toutes les tables si vous le souhaitez, ou vous pouvez interroger toute la table qui peut être stockée dans différents emplacements. Donc, même si les partitions vont diviser nos tables pour les rendre plus efficaces. Et ils peuvent rendre nos requêtes plus efficaces si nous utilisons les filtres appropriés, cela n'aura toujours pas d'
autre effet négatif sur vous ou vous ne le remarquerez même pas autrement que les effets potentiellement positifs
que vous obtenez de lui. Les pétitions sont donc extrêmement cool parce qu'elles rendent les choses beaucoup plus efficaces. Pourtant, ils ne le font pas, vous n'avez pas vraiment à interagir avec eux d'une autre manière, sauf les utiliser à votre avantage. Maintenant, il existe également d'autres façons de concevoir des bases de données relationnelles ou des
tables pour rendre l'interrogation plus efficace. Et c'est en définissant des indices ou un réglage des indices supplémentaires. Donc, par exemple, disons que nous interrogeons souvent par des événements. Nous souhaiterons peut-être mettre en place un index supplémentaire pour chaque événement. Et de cette façon, notre base de données gardera effectivement la trace de quel enregistrement a quel ID d'événement, par exemple. Maintenant, l'indexation va nécessiter plus de stockage. Donc, évidemment, vous ne voulez pas indexer chaque chose parce que vous devez garder une trace de toutes ces choses. Mais dans la prochaine chose sur les bonnes colonnes peut rendre l'interrogation beaucoup plus efficace car maintenant vous avez une table de recherche rapide. Donc, plutôt que d'avoir à rechercher dans toute la base de données et trouver tous les enregistrements, vous pouvez plutôt référencer cette table de recherche et il vous indiquera quels enregistrements vous voulez. Ainsi, l'indexation se fait généralement sur les colonnes qui sont très souvent utilisées pour le filtrage. Et cela peut rendre les requêtes beaucoup plus efficaces. Maintenant, vous pouvez toujours faire toutes les choses normales sans filtrer sur les colonnes d'index. Et la prochaine chose est juste une autre façon pour
les concepteurs de bases de données de rendre l'interrogation des tables encore plus efficace. Et donc généralement, il va être que les colonnes qui sont très souvent utilisées pour le filtrage vont être index. Et cela va rendre les requêtes beaucoup plus efficaces. Et donc si vous savez laquelle des colonnes sont indexées, alors lorsque vous voulez faire votre filtrage, il est préférable de commencer à filtrer par ces colonnes. Et puis de cette façon, dans les requêtes suivantes que vous faites, vous aurez déjà besoin de parcourir beaucoup moins d'enregistrements car vous avez déjà réduit la taille de votre table en effectuant le filtrage. Et donc l'indexation, tout comme le partitionnement, est quelque chose qui ne peut nous affecter positivement que comme la requête ou parce que nous n'avons pas besoin de les utiliser. Mais si nous utilisons des index et des partitions de tables correctement, alors cela peut vraiment améliorer les performances de nos requêtes. Maintenant, quelque chose d'autre que vous pouvez également entendre parler en tant que relations de table. Il existe donc différentes façons dont les tables peuvent être liées à d'autres tables. Une de ces façons comme une relation individuelle. Maintenant, une relation un-à-un signifie qu'un enregistrement dans une table correspond à un enregistrement dans une autre table, mais qu'il ne doit correspondre qu'à 11 enregistrements dans cette autre table doit correspondre à un seul enregistrement dans la table d'origine. Vous avez donc deux tables si elles sont liées par une relation un-à-un qu'une ligne dans chaque table correspond à une et une seule ligne dans l'autre table. Ensuite, nous avons une relation un-à-plusieurs. Un à plusieurs signifie qu'une ligne une table correspond à plusieurs lignes ou à plusieurs lignes au moins. Et une autre table. Et plusieurs lignes dans cette autre table peuvent correspondre à une seule ligne de la table d'origine. Ainsi, par exemple, ou userinfo et notre journal des événements sont liés par une relation un-à-plusieurs, une ligne et notre UserInfo peut correspondre à plusieurs lignes et le journal des événements, puisque l'utilisateur peut créer plusieurs événements. Nous pouvons donc avoir plusieurs enregistrements qui ont tous le même ID utilisateur. Mais chacun de ces enregistrements ne fait référence qu'à une ligne ou à un enregistrement dans notre table userinfo. Et les informations sur les événements et le journal des événements ont la même relation. Enfin, nous pouvons également avoir une relation plusieurs-à-plusieurs, ce qui signifie que plusieurs enregistrements une table peuvent correspondre à un enregistrement d'une autre table. Et plusieurs enregistrements dans cette autre table peuvent correspondre à un enregistrement dans la table d'origine.
3. Types de données et schèmes de schématiques: C'est bon. Maintenant que nous en
savons un peu plus sur les bases de données
relationnelles, leur leur fonctionnement
et leur apparence
générale Dans cette leçon, je souhaite passer en revue les types
de données et les schémas. Commençons maintenant par
parler des types de données. Je vais juste avoir l'un des tableaux que nous avions ici dans notre leçon
précédente, afin que nous ayons cet élément visuel
auquel nous référer. Si nous examinons ce tableau et que
nous examinons simplement
certaines des valeurs, nous pouvons constater que différents types
de données
sont représentés ici. Par exemple, la colonne ID
semble contenir au moins des nombres entiers
ou des nombres. La colonne de nom
semble contenir du texte, le joint semble contenir une date ou une
autre information horaire, puis le message électronique
est à nouveau du texte. Lorsque nous définissons une table, plutôt que de laisser
chaque colonne prendre la valeur
qu'elle souhaite, il peut être judicieux
de définir le type de données que nous nous attendons
à voir dans chaque colonne. Cela est maintenant utile car,
d'un point de vue extérieur, vous pouvez rapidement voir
quel type de données doit figurer dans chaque colonne et ce que
vous vous attendez à y voir. C'est également une bonne chose car les
différents types de données nécessitent des
quantités de stockage différentes. Vous pouvez optimiser le stockage en choisissant le type de
données approprié
afin de ne pas bloquer l'espace de stockage
inutile qui n'a pas besoin d'être utilisé. Cela peut également être très
utile performances,
car si vous
utilisez les bons types de données , dans la plupart des cas, les requêtes
s'exécuteront
plus rapidement que si vous
utilisez simplement un type général pour tout, car les
opérations sont bien mieux définies pour ce que vous essayez de faire
exactement. Et c'est également intéressant, car
lorsque vous souhaitez saisir nouvelles données ou lorsque
vous consultez le tableau et que vous
souhaitez en extraire des données, sachez à quoi vous attendre. S'
il y a une incompatibilité, vous pouvez rapidement comparer
cela ou vous recevrez un message de
la base de données indiquant que vous avez essayé de saisir du
texte ici, par exemple, mais que ce champ
nécessite un entier ou ce champ devrait contenir une date ou une heure ou
quelque chose comme ça De cette façon, vos bases resteront probablement
plus cohérentes et seront moins sujettes aux erreurs,
car
ce contrôle de validation
est nécessaire pour s'
assurer que tout ce qui entre est du type
approprié. Bien entendu, comme vous pouvez le
constater, différents avantages, fois du point de vue de l'utilisateur, de la base de données elle-même et du point de vue de
l'efficacité , à la
fois en termes de mémoire, de performance et
de rapidité de nos requêtes. Examinons certains des types
de données
disponibles, en commençant par les types de données
numériques. L'un des nombres
les plus courants que vous
allez voir est un entier. Il existe également différentes
variantes d'un entier. Vous pouvez avoir un petit ou un petit entier et une grande
extrémité un grand entier. La différence ici
est la quantité d' espace qu'il alloue
à chaque valeur Vous pouvez voir que dans le cas du nombre entier, nous avons quatre octets
dans le petit bout, nous avons deux octets dans le gros
bout, nous avons huit octets. Nous pouvons
déjà voir ici que nous pouvons faire des choix qui
affecteront les performances. Par exemple, si nous
avons une base de données qui note les résultats des tests, il serait judicieux
d'utiliser un petit entier, car les résultats des
tests ne
peuvent probablement pas dépasser 100. Alors que si vous souhaitez stocker grandes quantités de nombres énormes, il peut être judicieux
d'utiliser de grands nombres entiers Sinon, vos
chiffres seront réduits à un moment donné et vous ne
pourrez pas augmenter. En fonction de ce que vous
attendez des données, vous pouvez réellement
faire les
bons choix pour
vous assurer de ne pas
utiliser inutilement de la mémoire supplémentaire Il y a aussi,
bien sûr, d'autres types. Il y en a
une autre appelée numérique ou une autre variante serait décimale Cela signifie simplement que nous avons
autant de précision que nous le souhaitons. Ce type de données n' est pas associé à un nombre défini
d'octets et il varie. Cela le
rend bien sûr beaucoup plus flexible du point de vue de l'
utilisateur, mais aussi un
peu moins efficace du point de
vue de la base de données, car il ne peut pas allouer des
quantités spécifiques données pour
chaque type de données ou pour chaque valeur qui va
entrer dans chaque enregistrement. Maintenant, nous avons également ce que on appelle la vraie et la
double précision. Les deux sont utilisés pour
stocker des nombres décimaux. Mais le réel peut aller jusqu'
à cinq décimales, tandis que la double précision peut aller jusqu'à 15 décimales Encore une fois, selon le
degré de précision dont
vous avez besoin, vous pouvez soit utiliser le réel
si après cinq décimales, cela n'a plus vraiment d'
importance, soit si vous vous souciez vraiment de
ces décimales supplémentaires, vous pouvez passer à la double
précision, par exemple,
pour vous assurer de conserver
toutes Ensuite, un autre type de données numériques que nous pouvons définir
est appelé céréale. Encore une fois, nous avons
la possibilité d'utiliser
soit de petites céréales, soit de
grosses céréales, soit simplement des céréales normales. Ce que sont les céréales, c'est une incrémentation
automatique. C'est vraiment bien
si nous voulons avoir une colonne supplémentaire
pour une clé primaire, mais cette colonne n'est pas
spécifiquement définie. Ce serait juste un
compteur de nombres qui s'incrémente. Le numéro de série s'incrémente
automatiquement. Par exemple, si nous voulons
avoir une clé primaire qui
enregistre simplement le numéro de ligne
ou un identifiant unique, nous
pouvons lui donner le
type serial car elle s'incrémentera automatiquement et
nous n'avons pas besoin de lui transmettre de valeur
supplémentaire Il s'assurera simplement qu'
il continue à s'incrémenter par à la valeur précédente
qu'il avait Vous pouvez également avoir le
choix, bien sûr, entre les petites céréales et les grosses céréales plutôt
que les céréales normales. Encore une fois, cela
dépend de la quantité de données que
nous nous attendons à
avoir dans notre base de données. Désormais, la
catégorie de type de données suivante est celle des données de type texte. Il existe un type de données appelé texte
, similaire
au type de données numérique ou décimal
que nous avions auparavant, qui autorise simplement des quantités
variables de Il ne s'agit pas d'un montant fixe, mais il peut encore varier
en fonction de l'entrée. Mais nous avons également des options
pour avoir, par exemple, un caractère ou un caractère,
puis nous définissons le nombre d'octets
que nous voulons lui allouer. Cela signifie que si nous disons, par
exemple, char 25, cela signifie
que nous allons
allouer 25 octets à chaque enregistrement
de cette colonne. Si nous ne montons pas jusqu'à 25 octets, nous
aurons
un peu de rembourrage, sinon nous serons coupés à 25 Là encore, nous pouvons définir des restrictions de taille des données
en fonction de nos attentes. Ensuite, nous avons également
la possibilité d'utiliser un caractère variable ou un caractère
variable, ce qui signifie simplement que nous pouvons
passer à autant de types. Encore une fois, pour tous ces éléments,
nous pouvons stocker des données texte, mais la quantité de
mémoire que nous utilisons pour chaque enregistrement que
nous ou pour chaque valeur l'enregistrement dans une
colonne spécifique que nous insérons va varier
en fonction du
type de données que nous choisissons ici. Maintenant, il existe des types de données
supplémentaires spécifiques à la date et à l'heure. Nous avons des options d'horodatage, qui ne seront
que des horodatages, mais nous avons également un horodatage TZ, et nous les
avons également à d'autres endroits,
où nous pouvons emporter des informations supplémentaires où nous pouvons Nous choisissons d'utiliser l'
horodatage avec le fuseau horaire ? Cela va également
augmenter à nouveau la quantité de stockage dont nous avons besoin pour
chaque élément qu'il contient. Nous pouvons alors avoir
un type de données de date, plus petit que l'horodatage, car
nous n'avons plus qu'
à nous soucier de la date et pas d'informations supplémentaires
sur les heures, les minutes, les secondes ou même les millisecondes si c'est quelque chose
que La date, encore une fois, dépend du degré de
précision
que nous voulons obtenir dans nos informations temporelles. Avons-nous affaire à des dates
et leur précision est-elle suffisante, ou avons-nous besoin d'
horodatages spécifiques, par exemple Bien sûr, nous pouvons également
gérer le temps, ce qui est encore une fois un
moyen de stocker la date, mais en plus de la date, nous
pouvons également stocker l'heure. Là encore, nous avons la
possibilité d'utiliser également le fuseau horaire. Mais si nous utilisons le fuseau horaire, nous
aurons à nouveau besoin plus de stockage de données, car encore une fois, nous devons stocker ces informations de
fuseau horaire supplémentaires. Maintenant, généralement, si vous
n'utilisez pas le fuseau horaire, le fuseau horaire par défaut à utiliser
sera l'heure UTC. La plupart du temps,
pour économiser de l'espace, vous pouvez utiliser l'heure ou l'
horodatage sans fuseau horaire et vous assurer
que toutes les données que vous saisissez
sont en heure UTC Enfin, il existe également un autre type de données
intéressant
appelé intervalle,
qui, comme son nom
l'indique, représente des intervalles
entre différents moments. Cela peut être très
utile car cela nous
permet de faire des calculs
basés sur le temps. Par exemple, regarder
une semaine en arrière,
avancer d'une semaine , aller à demain
ou dans la dernière heure. L'intervalle est
un autre type de données, très cool à utiliser. Comme vous le verrez lorsque nous arriverons à la section diurne consacrée à l'
écriture des requêtes SQL. Cela peut également être très
intéressant dans les requêtes elles-mêmes. Eh bien, nous avons d'autres types de
données. L'un d'eux est un booléen. Il s'agit d'un très petit type de données, et nous ne
stockons ici que informations sur le vrai ou le faux. Cela ne peut prendre que deux
valeurs, deux ou faux. Nous avons l'argent, qui
peut être utilisé pour la monnaie, nous avons l'octet A, qui peut être utilisé pour stocker des chaînes d'
octets. Nous avons énuméré, qui
n'est qu'un type de données personnalisé
que nous pouvons créer Où nous pouvons attribuer une série d' éléments ou une série d' objets et leur attribuer
un ordre. Par exemple, nous
pouvons utiliser enumerate pour énumérer les différents
mois de l'année De cette façon, nous pourrons
comparer les commandes des mois. Par exemple, nous pouvons dire en utilisant un type de données d'énumérateur que le mois d'
avril vient après Alors que si nous les
stockions simplement sous forme de texte, nous ne serions pas en mesure de le faire. L'énuméré est un
type de données personnalisé ou défini par l'utilisateur que nous pouvons créer, dans lequel nous pouvons donner un
ordre spécifique aux objets Maintenant. Une extension de cela serait alors simplement des types de
données généraux définis par
l'utilisateur dans lesquels nous pouvons définir nos propres types de données, puis les utiliser
dans notre table elle-même. Maintenant, à mesure que Postgres se développe ou généralement à mesure que les
bases de données relationnelles se développent, d'autres types de
données personnalisés sont également introduits qui peuvent ne pas être initialement naturels
au système lui-même Par exemple, le JS, le XML, les tableaux, les recherches de
texte, les UUID, les données
géométriques
ou les types de données réseau s'agit essentiellement de types de données d'
extension qui apparaissent, car il
peut être très utile de stocker
ce type de données, car
il est de plus en plus courant de voir ces types de données apparaître. Pouvoir le mettre
dans une table dans
une base de données relationnelle
peut être très agréable Mais encore une fois, il s'agit de types de
données personnalisés qui sont des extensions. Au fil du temps, il est
probable que de plus en plus de types de
données personnalisés
seront également disponibles. Cela dépend également de ce que
la situation exige. Comme vous pouvez le constater, il
existe une grande variété de types de données auxquels nous avons
réellement accès. Mais en général, les types de données que vous allez
voir se concentreront davantage sur les types
de données de base. Il peut être
très intéressant de savoir quels types de
données sont disponibles
et ce qu'ils types de
données sont disponibles
et ce qu'ils
représentent, car lorsque vous
parcourez un tableau et que vous essayez de le comprendre, vous le reconnaîtrez
et aussi si vous devez prendre la décision
de créer une nouvelle table, comprendre les options qui s'
offrent à vous et peut-être même
être capable de réfléchir à un un petit aperçu de la façon dont je peux optimiser l'efficacité
en
m'assurant d'utiliser le bon type de données et en allouant la bonne
quantité de stockage de données pour cela Maintenant, l'autre point
dont je voudrais parler concerne les schémas Maintenant, en général, lorsque
vous faites référence à des schémas, cela signifie généralement
que nous
avons un schéma qui représente un ensemble de tables
ainsi que des informations sur
chacune des tables Mais il est également courant d'
utiliser le mot schéma pour définir les propriétés et
les structures d'une table elle-même. Par exemple, examinons cette requête SQL en bas
à gauche, mais ne vous inquiétez pas
trop pour la requête. Regardons simplement
les éléments à l'intérieur. Ce que nous pouvons voir ici,
c'est que nous avons un identifiant, qui est un
type entier qui peut également être abrégé pour t. Nous pouvons voir
qu'il s'agit de la clé primaire, et nous pouvons voir qu'elle n'est
pas non plus autorisée à prendre des valeurs
nulles Ce que nous faisons ici,
c'est simplement définir notre tableau d'informations utilisateur sur
le côté droit. Nous pouvons voir ici que notre table d'identification est actuellement définie pour
contenir des types de données entiers. Elle est également définie comme
étant la clé primaire, et elle n'est pas non plus autorisée
à porter des valeurs nulles. La colonne suivante sera le nom. Ici, nous avons décidé d'utiliser
le type de données Varchar, qui signifie que dans ce cas, nous lui avons attribué 25 octets, ce qui signifie que nous partons du principe que nos noms ne dépasseront pas 25 car c'est la
quantité de stockage que nous avons allouée à chaque élément que nous allons ajouter
à chaque Ici, il y
aura un type de données de date, car si nous
examinons la colonne, stockons en fait que
des informations de date, nous ne stockons pas d'informations
temporelles supplémentaires. Pour rendre le stockage un
peu plus efficace, nous n'avons pas besoin de stocker informations supplémentaires sur l'heure, mais uniquement sur la date. Si nous voulons stocker des informations supplémentaires
sur l'heure,
nous ne sommes évidemment pas autorisés à
utiliser le type de données de date car cela ne contiendrait pas
suffisamment d'informations. Enfin, nous avons
le champ e-mail. Ici, nous avons décidé d'utiliser
le type de données texte car les e-mails peuvent avoir des liens
très variés. Il est également important de s'
assurer que les utilisateurs disposent d'e-mails. Si un utilisateur s'inscrit
par e-mail et qu' reçoit un e-mail très long ou
très court, il est difficile de prévoir
combien de temps les utilisateurs pourront
envoyer leurs e-mails. Nous pouvons maintenant faire quelques
suppositions à ce sujet. Mais bien entendu, nous ne voulons pas qu'
un utilisateur saisisse son adresse e-mail. Ensuite, notre base
de données indique que nous n'avons pas assez d'espace de stockage alloué pour stocker l'intégralité du courrier électronique. Nous avons donc décidé d'
utiliser le type de données texte, mais vous pouvez également en faire
une décision plus éclairée. Si vous avez déjà des données sur un groupe d'utilisateurs et
un tas d'e-mails, vous pouvez voir la taille ces e-mails,
puis peut-être laisser un
peu d'espace supplémentaire et peu d'espace supplémentaire utiliser quelque chose comme un type de données
varchar Ce que vous pouvez voir en
bas à gauche ici est essentiellement la
définition du schéma de notre table. Peut voir ce qu'
est chaque colonne et quel
type de données elle contient. Nous pouvons voir ici, à partir de cette requête, juste des informations sur
notre table elle-même. Nous savons qu'il comporte quatre colonnes, l'ID, le nom, le joint dans l'e-mail, et nous connaissons également le
type de données de chaque colonne, qui signifie que nous savons également quelles valeurs attendre
de chaque colonne, ainsi que si nous
voulons insérer des valeurs, quelles valeurs doivent être
placées dans chaque colonne. Jetez un coup d'œil à un autre tableau, particulier à notre tableau des journaux d'
événements. Ici, un schéma va
être un peu différent et nous
avons la clé d'événement, qui sera ici
un type de données série car la clé d'événement va simplement
s'incrémenter à chaque Si nous attendons beaucoup
de données parce que nous avons
une très grande plateforme, nous voulons
peut-être même
utiliser la grande série ici. La clé Vent
sera une clé primaire. Encore une fois, il n'est pas
autorisé à être nul. Ensuite, nous allons avoir
la colonne ID de l'événement, qui sera un entier. Vous pouvez voir ici, également en comparaison avec la colonne d'
ID utilisateur ci-dessous, que nous pouvons utiliser à la fois un nombre entier ou un entier. C'est juste un raccourci
pour un entier. Encore une fois, nous disons que l'
identifiant de l'événement n'est pas autorisé à être nul. Ensuite, nous avons l'heure, qui dans ce cas est en fait
un horodatage. Nous pouvons voir ici que nous
avons des informations temporelles, mais il s'agit d'un format similaire à un
horodatage . Nous voulons donc nous
assurer que nous utilisons le type, puis que nous
avons l'ID utilisateur, qui sera
à nouveau un entier. Encore une fois, nous allons dire qu'
il n'est pas autorisé à être nul. Maintenant, nous sommes
également en train définir nos deux clés étrangères, puisque notre journal des événements
contient deux clés étrangères. Nous pouvons voir l'
ID utilisateur dans notre journal des événements référence à la colonne ID
dans le tableau des informations utilisateur. Nous pouvons le voir à nouveau, juste
à partir du lien ici. Dans notre tableau d'informations sur les événements, nous avons l'ID de l'événement dans
le tableau du journal des événements, fait référence à la colonne ID
dans les informations sur les événements. Nous pouvons donc voir à partir de la
requête en bas à gauche, mais aussi de la
définition du schéma de notre table, nous comprenons que notre journal des
événements
comporte à nouveau quatre colonnes, la clé de l'événement, l'ID de l'événement, l'
heure et l'ID utilisateur. Nous connaissons également le type de
données de chacun. Nous savons ce qu'est la clé primaire, et nous comprenons également les liens
de clé étrangère vers notre colonne d'ID utilisateur, ainsi que l'ID d'
événement et les
colonnes référencées dans les autres tables. Donc oui, c'est ainsi que nous pouvons définir les schémas
des tables individuelles Mais il en va de même si vous
lisez les informations concernant une nouvelle table et que vous êtes peut-être simplement quelqu'un qui a dépassé votre nouvelle
table et que
vous pouvez utiliser, vous pouvez consulter la définition du
schéma de la table pour comprendre
quelles colonnes sont disponibles, mais également quels types de données, comment ils sont stockés, ainsi que
quelles sont les références. Encore une fois, ne vous inquiétez pas
trop à propos la requête, car c'est
ce que nous allons
apprendre très bientôt. Sachez simplement que
c'est ainsi que nous
pouvons définir les schémas
de nos tables, et c'est également ce que
signifient
les définitions de schéma pour nos tables , afin que nous puissions définir
correctement
notre table dans son ensemble,
ainsi que les types de données correctement
assignés,
ce qui peut être excellent pour
la base de données elle-même
afin de garantir également un ainsi que les types de données correctement
assignés, ce qui peut être excellent pour la base de données elle-même
afin de garantir stockage de mémoire efficace et c'est également ce que
signifient
les définitions de schéma pour nos tables, afin que nous puissions définir
correctement
notre table dans son ensemble,
ainsi que les types de données correctement
assignés,
ce qui peut être excellent pour
la base de données elle-même
afin de garantir également un stockage de mémoire efficace.
pour rendre les
requêtes plus efficaces. Mais c'est également intéressant
du point de vue de l'utilisateur car nous savons quelles
données sont censées entrer, à quelles données nous pouvons nous attendre, ainsi que les liens qui peuvent
exister entre les différentes tables et comment
ces tables sont liées.
4. [Mac] Créer un serveur de PG local: Nous allons maintenant
commencer à voir comment faire
fonctionner PostGress sur notre
machine afin pouvoir réellement commencer à l'utiliser Maintenant, si vous travaillez dans une
entreprise ou autre, il est
très probable que votre base de données soit en ligne quelque part Vous aurez
donc les informations de
connexion. Mais ici, nous allons
apprendre comment
configurer un serveur local auquel nous pouvons nous connecter pour les bases de données afin que
nous puissions simplement
suivre et tout conserver
sur notre machine locale. Ensuite, si vous travaillez
avec une autre base de données, vous n'aurez
qu'à modifier les connexions
que nous allons
examiner dans les vidéos suivantes. Il n'y a pas grand-chose d'autre à cela, selon la base
de données que
vous allez utiliser, vous devrez alors vous
connecter à une autre source. Mais voyons maintenant comment nous pouvons réellement le faire fonctionner
sur notre machine locale. Nous allons aller sur
postreql.org. Ensuite, une fois que
nous serons là, nous allons appuyer sur le bouton de téléchargement ici pour
accéder à la section de téléchargement. Maintenant, en fonction de votre système
d'exploitation, vous devez vous assurer choisir le bon
package pour cela. Je suis sur Mac, je vais donc
cliquer sur macOS. Ensuite, je vais
faire défiler la page jusqu' à l'application PostGress Il s'agit d'une très belle
application interactive visuelle
conviviale que nous pouvons utiliser. Je vais
cliquer ici, ce
qui m'amènera à cette page. Ensuite, je vais me
diriger vers les téléchargements, puis cliquer sur le bouton de
téléchargement ici, puis cela
lancera votre téléchargement, vous pourrez ensuite utiliser pour obtenir que vous pourrez ensuite utiliser pour obtenir
le fichier dont nous avons besoin pour
effectuer l'installation. Une fois le téléchargement terminé, je vais simplement
ouvrir le fichier obtenu. Ensuite, je vais juste prendre cette icône de post grass et eh bien, selon les normes
Mac, la faire glisser
dans l'application. Ensuite, une fois
la copie terminée, je peux aussi ouvrir mon dossier d'applications, et nous pouvons voir ici
qu'il est juste en train de s'installer. Ensuite, pour l'ouvrir, il me
suffit de double-cliquer ici. Ensuite, cela nous
ouvrira la postgress que nous pourrons utiliser
pour
héberger notre serveur local Cliquez également sur Ouvrir ici. Si c'est la première
fois que vous l'ouvrez , alors
c'est parti. Voici à quoi ressemblera votre
client visuel. Vous allez également
avoir une petite icône
qui l' accompagne ici. Ensuite, si nous voulons
démarrer un serveur local, il suffit de commencer ici, et vous pouvez voir que nous avons
maintenant un serveur en cours d'exécution. Par défaut, vous n'aurez trois bases de données
sur votre machine, une portant le nom de l'
ordinateur que vous avez configuré, une appelée Postscri, puis
une autre appelée template one Il s'agit de trois
bases de données différentes qui sont
maintenant configurées pour nous sur notre machine, auxquelles nous pouvons accéder. L'important est que nous devons nous assurer que
si nous utilisons l'une de ces bases de données,
notre serveur fonctionne réellement. Parce que si nous cliquons sur Stop, nous ne pouvons plus nous y
connecter. Si vous rencontrez des problèmes de
connexion, assurez-vous
simplement que votre serveur fonctionne et que le nom de la base de données que vous utilisez également est correct. Ensuite, la vidéo
suivante vous montre comment nous pouvons nous connecter
à ces bases de données. Maintenant, vous pouvez également gérer
cela à partir de l'icône ci-dessus. Vous pouvez voir que nous pouvons également simplement nous
arrêter ou servir ici. Si nous le voulons, nous pouvons également le citer
intégralement depuis la barre de menu ou simplement le citer depuis
notre application Mais oui, je vous
recommande laisser activé pendant que vous
suivez le cours, juste pour vous assurer que vous aurez toujours
accès à la base de données.
5. [Windows] Postgres de locaux Postgres Server: Voyons maintenant comment installer notre
serveur Post Gress sous Windows Encore une fois, nous allons nous diriger
vers le postgres ou ici. Ensuite, nous allons accéder
à l'onglet téléchargements, auquel nous pouvons actuellement
accéder soit ici, soit simplement en cliquant
sur le bouton ici. Ensuite, nous allons
cliquer sur Windows ici. Ensuite, ici, nous allons
télécharger le programme d'installation, qui sera destiné à version 12, et c'est
ce que nous voulons ici. Nous allons télécharger
le programme d'installation Windows pour la version 12 actuellement. Ensuite, il suffit de l'enregistrer
et de le laisser télécharger. Maintenant, une fois que c'est téléchargé, vous allez
vouloir l'ouvrir. Je vais l'exécuter ici en
tant qu'administrateur, puis vous allez dire, ici. Ensuite, une fois que notre
programme d'installation sera ouvert, nous pourrons simplement y accéder, et nous allons passer la configuration ici, donc nous
allons cliquer sur Suivant. Choisissez où l'installer. Nous allons simplement
tout laisser coché
ici, cliquez sur Suivant Encore une fois, il suffit de tout laisser
dans la position par défaut. Nous devons maintenant
fournir une base de données, un mot de passe pour notre base de données, et il est important que
vous vous en souveniez. Nous pouvons voir ici que notre utilisateur
va publier. Je vais juste utiliser
le mot de passe postgres pour les deux Mais bien sûr, vous pouvez le régler
sur ce que vous voulez. Mais je vais faire en sorte que mon
mot de passe soit le même que le nom d'utilisateur, par
souci de simplicité, car c'est de toute façon une chose locale. Ensuite, continuez et cliquez sur Suivant. Laissez le
port par défaut 5432 ici, puis cliquez sur Suivant Encore une fois, je vais
simplement laisser
cette valeur par défaut ici et cliquer sur Suivant, puis sur Suivant ici ,
puis démarrer le processus
d'installation. La configuration est terminée, puis vous atteindrez simplement l'écran de
fin. Il vous demandera si
vous souhaitez simplement
lancer Stack Builder dès maintenant. Tu n'es pas obligée.
Tu peux prendre ça. Si vous êtes parti pour cocher la case et que vous avez
appuyé sur Terminer en réaction, vous pouvez également simplement
cliquer sur Annuler ou sur Fermer dans l'
application Stack Builder suivante qui s'ouvre Nous n'avons pas besoin de l'utiliser.
Vous pouvez simplement appuyer sur Terminer ici. Maintenant, pour accéder à notre panneau d'administration, nous allons accéder à
notre fonction de recherche. Nous allons
rechercher PG Admin. Ici, nous avons le formulaire d'administration PG. Ouvre ça. Une fois que c'est ouvert, il va l'ouvrir dans un
navigateur comme nous pouvons le voir ici. Maintenant, j'allais nous
demander de simplement définir un mot de passe principal pour Post Cris. Administrateur. Je vais juste
définir un mot de passe ici. Il n'est pas
nécessaire que ce soit le même que celui que vous avez défini lors de l'installation, mais assurez-vous de noter les deux mots de passe utilisés
ici.
Ensuite, tu peux appuyer sur OK. Ensuite, nous pouvons aller,
par exemple, dans le navigateur. Maintenant, si nous voulons
regarder le serveur Postgress, c'est
ce que nous avons fait lors de
l'installation de Postgress Nous allons maintenant devoir utiliser le mot de passe que nous avons défini pendant
le processus d'installation, pas le mot de passe principal
que nous venons de créer ici, mais le mot de passe que nous avons
utilisé lors de l'installation. N'oubliez pas que j'ai utilisé le
mot de passe postgress ici puisque nous nous connectons
à l'utilisateur postgres Je vais saisir ici le
mot de passe que j'ai défini lors du
processus d'installation que nous avons effectué ou que nous avons effectué il y a quelques minutes, en cliquant sur OK. Et puis nous pouvons voir ici, maintenant j'ai essentiellement accès à la base de données post-Postgres sur
le serveur ici Vous pouvez également voir qu'en
entrant dans l'onglet ici, nous avons également cette
option, où nous pouvons , par
exemple, l'
ouvrir dans une nouvelle fenêtre, ce que nous avons ici. Mais c'est aussi ainsi que
vous pouvez l'intégrer dans votre barre des tâches, et nous
avons ici la base de données, que nous
explorerons également un peu plus tard. Dans les cas ultérieurs, lorsque nous voulons
simplement nous connecter à notre base de données Postgres ou au
serveur Postgres local dont nous disposons, assurez-vous d'utiliser nom d'utilisateur et
le même passe que ceux que vous avez définis
lors de l'installation Nous verrons plus tard, lorsque nous
examinerons Data Grip. Par
exemple, dans le cas du MAC, nous n'avons pas besoin de définir ou fournir un nom d'utilisateur et un passe parce que
nous n'en avons pas défini un. Dans le cas de Windows, encore une fois, pour l'exemple de data grip
que nous aborderons bientôt. Assurez-vous d'utiliser l'utilisateur
Postcres comme nous l'avons fait ici
pour vous connecter au serveur,
puis assurez-vous d'
utiliser le mot de passe que
vous avez défini pendant le processus d'
installation,
pas le mot de passe que vous avez défini comme mot de passe principal ici,
mais
le mot de passe que vous avez défini pendant le processus d'installation, qui est le même que celui que
nous avons également saisi ici lorsque nous avons
été invités lorsque nous avons essayé de
allez sur le serveur. Encore une fois, le
nom d'utilisateur sera Postcre, puis le
mot de passe sera celui que
vous avez défini lors du processus d'installation
6. Mise en place de Postico postico [Mac]: Dans cette vidéo, nous allons découvrir comment
nous pouvons réellement nous connecter à notre base de données et commencer à y
écrire des requêtes SQL. Si vous utilisez un Mac, il
existe une interface sympa que vous pouvez utiliser pour vous
connecter, appelée postco Il s'agit simplement de la page de téléchargement sur
laquelle nous nous
trouvions la dernière fois. Si vous êtes dans l'
onglet d'introduction et que vous faites défiler la page vers le bas, vous pouvez voir ici
un lien vers postco Je l'ai déjà ouvert
dans un nouvel onglet ici. Ensuite, vous pouvez simplement le télécharger
et le laisser s'arrêter localement. Ensuite, si vous voulez l'
ouvrir, nous pouvons nous rendre ici et voici ce que
vous allez voir. Actuellement, nous n'
avons aucune base de données ou nous ne sommes connectés à aucune base de données. Mais passons simplement en
revue la configuration. Ce sera
la même chose en
fonction des autres plateformes
que nous examinerons également. Mais passons-en en
revue ici aussi. Nous pouvons donner un surnom
à notre base de données. C'est juste pour que nous comprenions
ce que nous cherchons. Ici, nous pouvons dire, par exemple, ma première base de données ou si vous voulez lui donner
un nom plus spécifique, bien
sûr, vous pouvez héberger ici ce
sera notre hébergeur local. Nous voulons que cela reste le cas. Notre port
sera le port 5432 Il est important que
nous gardions cela également. Si nous revenons également
au postcras,
celui-ci sera également
exécuté sur le port Il est important que nous nous
assurions simplement de rester les mêmes. Utilisateur, nous pouvons également garder le même. Aucun mot de passe n'est requis car nous l'
exécutons sur un hôte local. La base de données que nous pouvons
connecter à la base de données par défaut sera
simplement le
nom de l'utilisateur, que nous avons ici. Si nous allons dans notre postgres, nous pouvons également voir
que cette base de données existe. Mais nous pouvons également voir que
nous avons différentes options, par
exemple celle de
Postgres ici, ainsi que celle du modèle Vous pouvez vous connecter à n'importe lequel d'entre eux. Je vais me connecter
au modèle 1. Si vous ne mettez rien
ici, vous
utiliserez simplement les valeurs par défaut
qu'il contient ici. Une fois que nous sommes prêts, il suffit de cliquer sur OK. Maintenant que nous avons configuré la connexion à la
base de données, nous pouvons simplement cliquer sur Connecter ici, puis nous allons ouvrir cette nouvelle fenêtre, où
nous pouvons voir, nous pouvons accéder à la
requête SQL de l'éditeur de requêtes, et là nous pouvons
écrire nos requêtes. la barre de menu ci-dessus, nous pouvons également voir à quelle base de données nous sommes
connectés. À l'heure actuelle, nous pouvons voir que nous sommes
connectés au modèle 1. Mais si nous cliquons simplement sur
arrière-plan de ma première base de données, surnom que
nous avons donné à notre base de données,
nous voyons que le
serveur
auquel nous sommes connectés
possède en fait trois bases de données. Si nous le voulons, nous pouvons également nous
connecter aux différents. Nous pouvons voir ici que nous sommes
dans ma base de données de noms d'utilisateur, ou nous
pouvons sortir et passer au modèle 1 ou nous pouvons sortir et la base de données
Postgres Vous pouvez voir que pour chacune d'entre
elles, nous pouvons également ouvrir l'éditeur de requêtes et en fonction de la
base de données dans laquelle nous nous trouvons. Eh bien, ce sera celui auquel nous serons
connectés
et auquel nous allons
écrire des requêtes. Si nous voulons créer
une nouvelle base leur serveur
ou sur notre serveur, nous pouvons également le faire en
cliquant simplement sur le bouton de base de données ici, puis nous pouvons donner un nom à
notre base de données si nous voulons ou pour la supprimer, nous pouvons simplement cliquer sur Supprimer ici, puis nous tapons simplement base de données et cela
supprimera cette base de données. Si nous voulons revenir à l'option où nous le
connectons réellement à cette base de données, nous pouvons accéder au fichier,
afficher la fenêtre des favoris, puis cela aura
la fenêtre d'origine dans laquelle nous nous sommes
connectés à la fenêtre d'origine dans laquelle nous nous sommes notre salle de
base de données. vous souhaitez configurer des connexions
supplémentaires, vous pouvez créer
un nouveau favori, recommandé de vous déconnecter
d'abord de celui-ci Nous sommes actuellement
en période d'essai gratuit. Si vous souhaitez créer de
nouvelles connexions ici, vous pouvez créer
un nouveau favori puis tout ira bien, puis vous pourrez configurer des options de
connexion supplémentaires. Vous pouvez en avoir un, par exemple, votre
côté local avec lequel vous
voulez jouer. Si vous en avez un au travail
ou ailleurs, vous pouvez également vous y
connecter ici. Comme vous pouvez le constater, lorsque
nous téléchargerons postco, vous utiliserez par défaut
la version d'essai La version d'essai est
gratuite, indéfiniment. Il possède juste un
nombre réduit de fonctionnalités. Mais à toutes fins utiles
, cela servira très bien. Mais bien sûr, si vous souhaitez l'activer, vous le pouvez bien
sûr. Mais assurez-vous simplement de
regarder toutes les différentes vidéos ou de regarder au moins également
l'autre vidéo. Je vais
parler d'une gestion des données, juste pour que vous puissiez
voir les différentes interfaces
utilisateur que
vous pouvez utiliser ou les différents
services de
connexion
ou applications de connexion que vous pouvez utiliser afin de décider
lequel vous convient le mieux, lequel vous préférez. Ensuite, je vous recommande de vous
en tenir à celui que vous appréciez le plus et avec lequel vous vous sentez
le plus à l'aise. Ouais,
7. Configuration de Datagrip: Maintenant, le prochain outil
que je vais
vous montrer pour vous connecter à des bases de données et faire toutes ces
choses intéressantes en
écrivant des requêtes ce sera une manipulation de
données par des cerveaux de jet. C'est également celui que nous
allons utiliser
tout au long du cours. Vous pouvez l'obtenir en
allant sur jet brain.com, puis en allant dans Outils, et ici sur Data Grip. Avec Data Grip, vous aurez droit
à un essai gratuit de 30 jours, pourrez
suivre le cours et suivre quelques
exercices supplémentaires. Mais si vous l'appréciez,
il existe une version payante. Il y en a, comme nous l'avons également vu avec
postco ou d'autres GYs. Il existe, bien sûr, d'autres systèmes
gratuits que vous pouvez utiliser, selon
ce que vous aimez ou si vous avez joué
avec d'autres. Vous pouvez alors choisir d'opter pour Data Grip ou vous pouvez, bien
sûr, également choisir un
autre système. Au final, cela n'a pas vraiment d'
importance. Tout cela va simplement se
connecter à nos
bases de données et à tout le reste. C'est celui avec lequel tu te
sens le plus à l'aise. Nous allons donc
commencer par un essai gratuit de 30 jours. Si vous souhaitez suivre le cours exactement,
vous pouvez bien sûr vous
familiariser
avec les données ici. Une fois votre période d'essai expirée, vous pouvez décider
si vous souhaitez
continuer à utiliser Data
Grip ou si vous
souhaitez utiliser une autre interface graphique
proposant des services gratuits, par
exemple un code postal dont nous avons
vu qu' il propose un essai gratuit à vie, et là, vous pouvez simplement
continuer à l'utiliser gratuitement. Cela dépend entièrement de vous. Mais allez-y et téléchargez Data Grip. Une fois cela fait, il vous suffit
de suivre la configuration et de l'ouvrir. Maintenant, une fois que vous avez téléchargé
une poignée de données ouvertes, y serez
redirigée lorsque vous l'ouvrirez au cas où vous n'auriez pas cette
fenêtre dans la barre latérale. Vous pouvez l'obtenir très
facilement en accédant à la fenêtre d'affichage, puis
en cliquant sur la base de données ici. Ensuite, cela va simplement
ouvrir ou fermer la fenêtre sur
le côté gauche. Pour me connecter à une base de données ici, je vais simplement
cliquer avec le bouton droit sur une nouvelle source de données. Je vais sélectionner
Postgress QL ici. Cela va nous permettre de
configurer une source de données Postgres Je vais cliquer
dessus, et cela
va faire apparaître cette fenêtre de
connexion ici. Si vous ne voyez pas Postgress laissez-moi le
refermer Si vous ne voyez pas de
postgress ici, il est probable qu'elle
soit juste ici. Une fois que vous
les avez déjà sélectionnés, ils seront
déplacés pour vous ici afin que
vous puissiez y accéder plus facilement. Ce ne sera probablement pas là pour vous
si vous n'avez jamais utilisé de groupe de
données auparavant, auquel
cas, il se
trouverait quelque part ici. Quoi qu'il en soit, allez-y
, ouvrez-le, et cela nous donnera notre fenêtre de connexion post-gress Là encore, on peut
donner un surnom. Ensuite, nous pouvons avoir nos options de
connexion. Notre hôte restera
l'hôte local. Notre port
sera toujours le port 5432. Nous n'avons pas besoin d'un nom d'utilisateur ou d'un mot de passe pour
les collecter dans la base de données locale. Ensuite, dans la base de données à laquelle
nous voulons nous connecter, nous pouvons choisir entre,
bien sûr, à nouveau Postgress Ou si nous ouvrons simplement notre application Postgress, nous avons
aussi, bien sûr, Temple One, ainsi que le nom d'utilisateur de l'
ordinateur que vous utilisez Nous pouvons ensuite simplement cliquer sur OK. Et cela va nous connecter
à une base de données, et
nous pouvons voir ici que nous avons également une console dans
laquelle nous pouvons
écrire nos requêtes SQL. Si nous le voulons, nous pouvons également explorer base de données en l'ouvrant, puis nous pouvons voir
la structure ici. Une base de données
y est déjà configurée par défaut. Mais il n'y a pas encore de tables dedans. Nous en
apprendrons davantage un
peu plus tard, une fois que nous aurons
abordé tout cela. Mais c'est ainsi que
nous pouvons nous connecter à
la base de données Postgres à l'
aide d'un groupe de données Au cas où vous
fermeriez accidentellement votre console ici, vous pouvez facilement la rouvrir
en cliquant avec le bouton droit sur ici, puis en ouvrant la console de requête. Maintenant, ce qui est aussi cool
avec Data Grip, c'est que nous pouvons avoir plusieurs connexions
de base de données ouvertes. Par exemple, je vais
ajouter une autre nouvelle source de
données ici, et je vais ajouter ici
une autre source de données postgres, et maintenant nous allons également nous
connecter au modèle 1 Nos paramètres ici vont
toujours indiquer qu'il en sera de
même sur l'hôte
local sur le port. Notre surnom ici
va juste être renseigné par défaut,
puis je pourrai cliquer. Nous pouvons maintenant voir que
nous nous connectons à une autre base de données ici
sur notre système local, qui est celle-ci. Ici. Ici, nous pouvons également voir que nous pouvons également y aller et l'explorer. La base de données
Postgres
contient en fait d'autres éléments
configurés par défaut contient en fait d'autres éléments
configurés par Mais encore une fois, nous
en apprendrons davantage
une fois que nous
aurons abordé la requête. C'est juste plus pour
nous assurer que nous avons la bonne configuration. Vous pouvez également voir ici que j'ai
maintenant deux consoles. Un qui est connecté
à notre postgres. Encore une fois,
ce sera notre surnom. L'autre qui concerne
le modèle de base de données 1. Bien entendu, si vous fermez ou l'autre d'entre eux
ou tous ces éléments, vous pouvez simplement revenir ici, cliquer avec le bouton
droit sur Ouvrir la console de requêtes, et également ici, nous pouvons
ouvrir la console de requêtes. voulez simplement Quelle que soit la
console de requête que vous utilisez, vous vous assurer qu'
elle correspond à la bonne base de données
au cas où
plusieurs bases de données seraient ouvertes. impression que l'
onglet de votre barre d'outils est trop
rempli. Vous pouvez également simplement cliquer à nouveau
sur la base de données, cliquer avec
le bouton droit de la souris et supprimer, ce qui supprimera la configuration
de la base de données. Une chose à noter à ce sujet est que la configuration
a également disparu. Si vous souhaitez vous y reconnecter, vous devrez en fait
suivre à nouveau les étapes de la
nouvelle source de données,
puis vous connecter à la source de données et saisir
les détails de configuration Mais si vous voulez le supprimer, c' est comme ça que
vous pouvez le faire.
8. Connexion CLI: Maintenant, l'autre option que
vous pouvez prendre et que vous pouvez parfois prendre est d'utiliser l'interface de ligne de
commande. Cela signifie simplement
utiliser le terminal ou quelque chose comme
ça pour se connecter à. Parfois, vous
voudrez peut-être l'utiliser. Personnellement, je préfère
les interfaces graphiques. D'autres fois, vous
serez peut-être obligé de le faire. Si,
par exemple, vous êtes connecté à une machine distante et que vous devez travailler sur la base de données qui s'y trouve, la seule option vous est d'utiliser une interface en ligne de
commande. Dans les deux cas, vous pouvez également utiliser
l'interface de ligne de commande. Pour nous, il sera facile de s'
y connecter car nous
avons notre serveur Postgres ici Nous pouvons simplement nous connecter ou
double-cliquer sur l'un d'entre eux, puis cela ouvrira la connexion dans
un terminal ici, puis nous pourrons écrire uniquement
nos commandes SQL ici. Voici les différentes options
qui s'offrent à nous. Dans ce cours, nous allons aborder le thème de la prise en main des
données. Mais bien sûr, tu peux
choisir ce que tu veux. Bien entendu, vous pouvez également
passer d' une
application à l'autre. En fin de compte,
peu
importe
lequel vous choisirez importe
lequel vous car ils fournissent tous
le même moyen
d'atteindre le même objectif,
à se connecter
à notre base de données et nous permettre de
rédiger nos requêtes. Celui avec lequel vous vous sentez le plus à l'
aise est celui
que vous devriez choisir, car en fin de compte, ils nous permettront tous de
faire la même chose.
9. Créer et laisser de bases de données: Maintenant que nous savons comment nous
connecter à une source de données. Allons-y et
découvrons comment créer une base de données à l'intérieur
de notre source de données. Je vais me connecter
au modèle, juste parce qu'il n'
y a pas de bases de données ou quoi que ce soit à l'intérieur,
il est complètement vide. Je vous recommande de
faire de même pour avoir une source de données complètement
nouvelle. Pour vous, il est même possible que lorsque vous cliquez sur
cette flèche déroulante,
vous ne voyiez rien, car général, ces dossiers
ne sont créés que si vous créez puis supprimez
une base de données par la suite. Pour vous, si vous
utilisez le menu déroulant, il est possible que rien ne s'affiche
réellement. Maintenant, si vous êtes
dans la configuration ici, par exemple, cela vous indique
que la base de données est introuvable ou que vous ne
pouvez pas vous y connecter. Par exemple, si j'essaie de me
connecter au modèle 2 ici. Avant de postuler, je peux également simplement tester la connexion. Si j'essaie cela, cela ne
fonctionnera pas car la
base de données n'existe pas. Dans ce cas, si vous souhaitez vous
connecter à une autre base de données, l'une des options consiste bien entendu toujours à vous connecter
à la base de données POC, qui doit toujours être incluse et créée sur chaque système Les autres sont généralement créés
sur les autres systèmes,
mais dans certains cas
, différents d'un
système à l'autre, la base de données peut ne pas être créée par défaut. Pour ce faire, nous pouvons simplement nous connecter
à postcras par exemple, puis nous pouvons soit l'
utiliser directement, soit accéder à
notre console de requêtes, et c'est également
ce que nous allons
apprendre dans la prochaine leçon, nous allons écrire
créer une base de données, et nous allons créer, par
exemple, le modèle deux, si c'est celui auquel
nous voulons nous connecter Ensuite, nous pouvons l'exécuter et nous pouvons voir ici qu'il s'
agissait simplement d'une mise à jour, et nous allons revenir
dans nos propriétés ici. Maintenant, si nous essayons de connecter au modèle deux,
nous testons notre connexion. Nous voyons ici maintenant que cela
fonctionne correctement. C'est simplement parce que
dans la vidéo, je vais
utiliser le modèle une base de données au cas où il
n'existerait pas pour
vous, vous pouvez le faire pour le créer
puis vous y connecter. Mais bien sûr,
vous pouvez également simplement utiliser la base de données
Postgres par défaut pour Mais allons-y et créons une base de données, car n'oubliez pas que lorsque nous avons découvert
le modèle relationnel, nous avons des tables qui se
trouvent dans une base de données Avant de créer des tables, nous devons d'abord disposer d'une base
de données dans laquelle placer ces tables. Comment créer une base de données ? Eh bien, voilà, je vais ouvrir
la console Querin. Vous remarquerez qu'il s'
agit de la console de mon modèle de connexion à une
source de données, comme le montre son nom ici. Si plusieurs sources de
données sont ouvertes, assurez-vous d'
utiliser la bonne console pour la bonne source de données. Assurez-vous également que
vous êtes connecté à l'aide votre post grass
pour vous assurer que votre
serveur postgress local fonctionne Si ce n'est pas le cas,
assurez-vous de cliquer sur Démarrer. OK, alors comment pouvons-nous créer une base de données dans notre
modèle de source de données One ? Pour ce faire, nous
allons utiliser ou taper dans notre console de
requêtes ici, créer une base de données, puis nous allons
taper ici le nom de la base de données, que nous allons renseigner dans une seconde. Ensuite, nous allons le terminer par
un point-virgule. Il y a quelques
points importants à noter ici concernant la structure générale des
requêtes SQL. Tout d'abord, toutes les
commandes SQL sont généralement mises majuscules par l'utilisateur afin de rendre la
requête plus lisible En outre, il est habituel de
terminer les commandes SQL
par un point-virgule Vous n'avez pas besoin de le faire,
mais cela indique que la requête est terminée et que vous pouvez en fait enchaîner plusieurs
requêtes ensemble Chaque fois que vous terminez une requête, vous pouvez mettre un
point-virgule ici pour gros que cette
requête est Créons notre base de données, et appelons-la notre base de données. Si nous l'exécutons, nous pouvons
voir que nous obtenons une console ici. Si nous allons dans les bases de données, nous avons
maintenant créé notre base de données. Il s'agit du nom de base de données
que nous lui avons attribué. Nous pouvons voir ici que nous obtenons également
des dossiers
supplémentaires. Ouais C'est ainsi que nous pouvons créer
une base de données. Et si nous voulons
supprimer une base de données ? Eh bien, nous devons alors
changer le create en drop. Ensuite, si nous l'exécutons, vous
remarquerez que notre
base de données a maintenant disparu. Nous pouvons constater qu'il a été
supprimé de notre source de données. Pour vous montrer que la mise en
majuscule n'est pas
nécessaire, pas plus
que le point-virgule Allons-y et répétons la même requête que celle que nous
avons faite au début. Mais cette fois,
tout est en minuscules, tout
en n'utilisant pas le
point-virgule à la fin Si nous l'exécutons, et c'est parti, nous pouvons ouvrir
à nouveau notre base nous pouvons ouvrir
à nouveau notre base de données et tout
redeviendra comme avant. Vous pouvez voir que vous pouvez
toujours écrire des requêtes SQL en minuscules et sans point-virgule Cependant, il est généralement recommandé
de s'en
tenir au
point-virgule à la fin d'écrire toutes les
commandes SQL en Parce que de cette façon, il est beaucoup
plus facile de lire la requête. Il
est facile de distinguer ce qui fait partie d'une requête SQL et ce qui peut être un nom qui
apparaît dans une table de
notre base de données dont
le nom est apparaît dans une table de
notre base de données dont similaire ou identique à celui d'une requête SQL. Et bien sûr,
créez également une deuxième base de données. Créons ici une autre
base de données appelée notre deuxième base de données. Utilisons ici quelques traits de soulignement
pour rendre cette base de données plus lisible
ou ce nom plus lisible Si nous allons de l'avant et l'exécutons, vous verrez que nous avons maintenant deux bases de données et notre
modèle une source de données. Vous pouvez voir que nous pouvons
examiner chacune d'entre elles, et chacune d'elles constitue
une base de données distincte. Bien entendu, nous pouvons les supprimer
à nouveau comme ceci, puis nous pouvons également supprimer notre première base de données en utilisant
le nom approprié. Ensuite, appelez l'instruction
drop database.
10. Créer des schèmes: C'est bon. Maintenant que nous savons comment créer et
supprimer des bases de données, voyons
comment créer et supprimer des schémas,
car c'est là que nous voulons
placer nos tables. Depuis notre dernière leçon, nous avons pu créer RDB ici Mais parfois,
vous pouvez rencontrer une erreur. Par exemple, si je tape ici, supprime base de données et que
je souhaite supprimer RDB, cela va me donner une
erreur car je suis déjà connecté à la base de données
actuellement ouverte Parce que j'y suis connecté, je ne peux pas vraiment le supprimer. Donc, une chose que vous pouvez faire pour changer cela
serait, par exemple, opter pour une
option différente de celle que nous avons ici. Nous voyons que nous avons notre base de données, qui sera
dans notre modèle, mais nous avons également différentes
options à explorer. L'autre chose que
nous pouvons faire si nous voulons
vraiment supprimer
une base de données est créer une nouvelle base de données. Par exemple, notre base de données de soulignement
Nous pouvons la créer,
puis nous devons modifier
notre connexion,
ce que nous pouvons faire en allant
ici et en cliquant sur RDB Nous pouvons la créer,
puis nous devons modifier
notre connexion,
ce que puis nous devons modifier
notre connexion, nous pouvons faire en allant
ici et en cliquant sur RDB Je suppose que ces
noms ne sont pas particulièrement utiles lorsque
vous les prononcez à haute voix, mais nous avons maintenant deux bases de données. L'un d'eux comporte un
trait de soulignement, qui est celui auquel nous sommes
actuellement connectés, comme nous pouvons le voir ici dans
le coin supérieur droit L'autre n'est pas
souligné, et ce n'est pas
celui auquel nous sommes connectés dans notre session en cours,
car encore une fois, ce n'est pas celui
que
nous avons ici dans
le coin supérieur droit Cela va
être spécifique à Data Grip, mais il est probable que vous aurez des indications d'interface utilisateur
similaires si vous utilisez différents éditeurs
SQL. Si nous le voulons, nous
pouvons, par exemple, supprimer notre base de données, puisque nous sommes maintenant connectés à la base de données qui contient
un trait de soulignement Si nous voulons supprimer la base de données à laquelle nous étions
connectés auparavant, nous pouvons maintenant supprimer la base de données, puis appeler le nom dans ce cas sans le trait de
soulignement, nous pouvons l'exécuter Nous pouvons maintenant voir que la
base de données a été supprimée. Une chose que vous remarquerez, c'est si nous examinons le schéma ici, nous ne pouvons réellement
voir aucun schéma Cependant, si nous examinons de
près notre symbole RDB ici, nous constatons que
nous sommes connectés à notre base de données de soulignement, qui est la base de données
publique, qui est le schéma Si tel est le cas, vous recevrez
probablement cette notification, que je
vois également ici depuis Data Grip où nous pouvons simplement
cliquer sur le schéma d'introspect Alors maintenant, si nous passons à notre schéma, nous pouvons voir qu'il est maintenant
disponible pour nous. Nous avons en fait le schéma
public disponible. Mais comment
créer un nouveau schéma ? Eh bien, pour ce faire, nous
tapons create schema, puis nous tapons simplement
le nom comme nous l'avons fait
pour la base de données. Par exemple, ici, nous pouvons
appeler
celui-ci notre schéma, et
nous pouvons l'exécuter. Pour moi, je l'ai déjà créé,
donc je reçois une erreur
qui existe déjà. Voyons comment nous pouvons le supprimer. Nous pouvons taper drop
schema, notre schéma. Ensuite, si nous l'exécutons, nous pouvons voir comment le
schéma est supprimé. Ensuite, si nous le voulons,
nous pouvons le créer à nouveau en tapant create schema, puis il créera
un autre schéma pour nous. Bien entendu, le
nom du schéma n'a pas besoin
d'être comme ça. Il peut s'agir du nom
le plus approprié. Si nous le voulons, nous pouvons le
supprimer à nouveau. Il est généralement habituel de ou. Il est généralement acceptable de s'en tenir au schéma public. Il
n'y a rien de mal à cela. Si vous avez déjà
un schéma public qui devrait être
présent par défaut, vous pouvez également
vous en tenir à un schéma public
sans trop vous inquiéter. Mais si vous avez spécifiquement
besoin ou souhaitez créer des schémas supplémentaires dans
lesquels regrouper les tables, vous savez bien sûr comment procéder et vous avez la
possibilité de le faire
11. Créer des tables: Voyons maintenant
comment créer tables dans nos schémas de
base de données Pour ce faire, la syntaxe que
nous allons utiliser sera de créer cette table de temps, et nous allons
avoir le nom de notre table. Par exemple, nous pouvons utiliser ici les informations utilisateur comme nous l'avons également
vu dans les leçons précédentes. Maintenant, il y a des choses supplémentaires
que nous devons faire ici. Nous voulons ouvrir et
fermer les parenthèses ici, et maintenant nous pouvons saisir
les noms réels colonnes
de notre tableau ainsi que le
type de données qu'elles contiennent Rendez tout cela
un peu plus beau. Je vais m'étendre
sur plusieurs lignes. Je vais également mettre
à nouveau un point-virgule à la fin, juste pour m'
assurer de ne pas l'oublier plus tard. Même si, comme
vous l'avez déjà vu, cela fonctionne sans elle,
c'est une bonne pratique
de l'avoir là. Prenons notre première colonne, l'ID, qui ne sera
qu'un entier. Voici
notre clé primaire. Maintenant, pour créer une colonne suivante, nous allons mettre une virgule
ici pour la séparer Ensuite, notre colonne suivante, disons
que ce soit le nom. Faisons en sorte que ce soit un
varchar utilisant 25 octets. Nous aurions pu rejoindre le prochain. Celui-ci, prenons
le huitième rendez-vous. Nous pouvons définir leur
adresse e-mail si nous le voulons, et celle-ci peut,
par exemple, être un champ de texte. Si nous l'exécutons, nous
pouvons voir ici notre table d'informations utilisateur a été créée dans
le schéma public. Nous pouvons
également voir ici que si nous y
entrons, nous avons également des informations
sur la clé primaire, ainsi que sur les colonnes qui
se trouvent à l'intérieur ou sur les attributs, ainsi que sur les types de données pour chaque
attribut de colonne que nous avons. Comment peut-on supprimer une table ? Eh bien, ça va
être beaucoup plus facile. Nous allons juste
taper drop table. Ensuite, nous allons mettre ici
le nom de la table. Par exemple, informations utilisateur,
point-virgule, appuyez sur Exécuter Allons-y. Oubliez de cliquer sur Exécuter
, puis attendez et vous pouvez voir ici que notre
tableau a été supprimé. Et si nous avions
plusieurs schémas ? Créons un deuxième schéma, et appelons-le à nouveau notre schéma. Alors exécutons-le.
Nous avons maintenant deux schémas Je vais juste y
revenir un peu afin que nous obtenions le code
que nous avions au préalable. Que se passe-t-il maintenant si nous exécutons notre instruction create table ?
Eh bien, essayons-le. Si nous exécutons notre instruction create
table, nous voyons ici que nous la
mettons dans le schéma public, qui est également celui auquel
nous sommes connectés ici. Nous disposons
de différentes options. L'une d'elles est que nous pouvons modifier
notre connexion ici. Par exemple, si vous vous connectez
à notre schéma, au lieu du schéma public, nous pouvons voir ici que notre
connexion a été modifiée. Ici, nous pouvons à nouveau créer
la table d'informations utilisateur. Cette fois, il
sera créé dans notre schéma. Parfois, il se peut que vous n'ayez pas le luxe de changer
de mode comme ça. Parfois, cela peut être différent. Dans d'autres cas, si vous
devez spécifier un schéma, vous pouvez également l'ajouter
en plaçant le nom du schéma
devant la table elle-même. Créons
ici une autre table appelée user Info two. Permettez-moi de corriger cette faute de frappe ici. Vous pouvez le voir même si je suis
connecté à notre schéma, qui est le schéma ici. J'ai créé une table d'informations
utilisateur dans le
schéma public, comme nous pouvons le voir ici. Bien entendu, si je supprime
ce préfixe ici et que je le
réexécute, il
sera créé dans le schéma
auquel nous sommes actuellement
connectés Vous pouvez voir si vous avez affaire
à plusieurs schémas, vous pouvez ensuite créer soit passant à eux et en créant des
tables directement dans ceux-ci,
soit, si vous le souhaitez, vous pouvez
référencer le schéma à l'
avance pour y créer des
tables dès maintenant Alors, que se passerait-il maintenant que nous sommes créés
selon notre schéma ? Allons-y et
revenons
au schéma public en
passant au RTB, en
passant en public, en cliquant Que se passe-t-il maintenant si nous voulons supprimer le schéma et supprimer le nouveau
schéma que nous avons créé ? Eh bien, nous
allons maintenant rencontrer un problème car nous avons créé des
tables à l'intérieur. Une chose que nous pouvons
faire, c'est continuer et supprimer
toutes les tables qu'il contient, puis nous pouvons
supprimer le schéma, ou comme Data Grepard nous le
suggère,
nous pouvons utiliser ce que l'
on appelle une cascade à la fin Nous pouvons taper cascade ici. Ensuite, il
effectuera simplement cette opération, mais il continuera
et il effectuera également
le nettoyage approprié à l'intérieur dans ce cas Si nous l'exécutons maintenant, non seulement notre schéma
sera supprimé, mais également toutes les tables
qu'il contient. Maintenant, nettoyons encore plus les choses. Allons-y également et supprimons
les
deux tables d'informations utilisateur afin d'éviter d'avoir des noms de
table étranges contenant les mêmes colonnes
en conflit. Allons-y et
abandonnons cette deuxième table. Voyons également comment créer les
deux autres tables que nous avons vues dans la leçon, afin pouvoir également
examiner les clés étrangères. Ici, nous pouvons à nouveau
créer une table, et créons notre table d'informations sur les
événements, les informations soulignement des événements Ici, nous allons avoir
deux colonnes à l'intérieur. L'un d'eux sera
l'ID, qui,
encore peut être un entier, et faisons-en
notre clé primaire. Ensuite, nous aurons
également le nom, que nous pouvons avoir sous forme de
texte ou de varchar,
ou ce que nous voulons, comme nous jugerons approprié Maintenant, une chose que je veux faire est de mettre ces noms en majuscules plutôt qu'en minuscules juste pour vous montrer
ce qui se passe ici. Si nous l'exécutons et que nous
accédons à notre tableau d'informations sur les événements, nous pouvons voir ici
que même si nous les avons créés avec des noms en
majuscules, lorsque nous entrons dans le tableau, nous n'avons toujours que des noms en
minuscules ici C'est aussi pourquoi
il est si agréable d'utiliser ces soulignements, car même si ces conversions se produisent, cela facilite la lecture Allons-y et
créons également la table du journal des événements. Ici, nous allons
avoir notre clé d'événement, qui sera en série afin qu'elle s'incrémente automatiquement Alors gardons nos deux identifiants ici et ne nous inquiétons pas trop
du reste. Nous allons avoir un identifiant d'événement, qui sera un entier. Ensuite, nous aurons
également un ID utilisateur, qui sera
également un entier. Ensuite, si nous le voulons, nous pouvons
également y ajouter, par exemple, la colonne de temps, ou nous
pouvons l'appeler heure en majuscules. Nous pouvons créer un horodatage,
mettons-le en majuscules Nous n'allons pas
ajouter d'heures ici car si nous l'utilisons, utilisez
simplement l'UTC, et
cela nous permettra d' économiser de l'espace de stockage. Maintenant que nous avons
nos quatre colonnes, comment pouvons-nous référencer
les clés étrangères ? Pour ce faire, nous allons passer
à une nouvelle ligne, et nous allons
dire clé étrangère, et vous vous en souvenez
peut-être déjà dans les
leçons précédentes. Nous allons ouvrir
et fermer les parenthèses. Nous allons mettre ici le nom
que nous voulons référencer
dans notre tableau, qui
sera l'identifiant de l'événement. Nous allons parler de références. Mais ensuite, nous allons mettre ici
le nom de notre table. Par exemple, informations sur les ventilations. Ensuite, nous allons mettre ici le nom de colonne que
nous voulons référencer. Dans ce cas, l'identifiant. Notre identifiant d'événement
sera une clé étrangère qui fait
référence à la colonne ID
et à la table d'informations sur les événements, et en faisant de même
pour les informations utilisateur ,
nous allons créer
la clé étrangère qui
sera notre ID utilisateur. Il va dire fait référence à
la table d'informations utilisateur, ici il va faire
référence à la colonne ID. Si nous allons de l'avant
et gérons cela, jetons un
coup d'œil à nos tableaux. Maintenant, nous avons également la table du journal des
événements. Nous pouvons voir ici que nous
avons la clé primaire, mais nous avons également des références à des
clés étrangères ici.
12. Modifier les tables: Maintenant, il est probable qu'au fil temps, les
exigences de votre base de données changent. Vous souhaiterez peut-être modifier des tables, ajouter des éléments, les
supprimer ou même
modifier des éléments qu'ils contiennent. Pour ce faire, nous pouvons utiliser
la commande alter table. Nous allons ensuite mettre le nom de la table que
nous voulons modifier, puis ce que nous
voulons exactement modifier à ce sujet. Voyons quelques exemples. Supposons que nous voulions également
ajouter une région à nos informations utilisateur. Nous disons que nous avons leur
identifiant, leur nom et la date à laquelle ils s'inscrivent
dans leur e-mail, mais nous ne savons pas vraiment dans
quelle région ils se trouvent. Dans quelle partie du
monde se trouvent-ils ? Nous allons dire que
nous allons
modifier notre tableau d'informations utilisateur. Dans ce cas, nous
voulons ajouter une colonne. Nous allons taper
ajouter. Ici, nous allons avoir le nom de la colonne, qui sera la région, puis nous voulons avoir
le type de données de la colonne. Nous pouvons dire, par
exemple, encore une fois, s'agisse d'un varchar, peut-être de taille 20 ou de ce que
nous jugerons approprié Ensuite, bien entendu, nous
voulons également nous assurer de mettre un point-virgule à la fin,
uniquement pour de bonnes pratiques. Ensuite, si nous l'exécutons et que nous regardons simplement le tableau des informations utilisateur, nous voyons maintenant que la colonne de
région y est ajoutée. Supposons qu'à un
moment donné, notre tableau devienne trop grand
et que nous décidions la colonne des régions n'est
en fait pas si importante. Ensuite, nous pouvons utiliser à la place de
la colonne de dépôt de commande. Maintenant, nous allons simplement mettre le nom de la colonne que
nous voulons supprimer. Nous voulons supprimer
la colonne des régions. Vous pouvez cliquer ou exécuter ici, puis cela le supprimera
de notre tableau d'informations utilisateur. Supposons qu'à un moment donné, nous nous rendions compte que notre
colonne d'identifiants devient trop grande, les nombres entiers qu'elle contient
deviennent trop grands et que nous devions modifier notre
colonne afin de pouvoir prendre en charge les identifiants plus grands, car
notre base d'utilisateurs devient de plus
en plus importante Ce que nous pouvons
faire pour cela, c'est créer ou nous pouvons
dire modifier la table, nous voulons modifier la table
d'informations utilisateur. Nous voulons maintenant modifier la colonne. Nous voulons modifier la colonne ID, nous voulons changer le type
de la colonne ID en, par
exemple, un grand. Nous pouvons gérer ça. Ensuite,
vous pouvez voir ici notre type à partir d'un entier
va maintenant être mis à jour
vers un grand type. Si nous le voulons, nous pouvons
également inverser cette tendance. Vous remarquerez ici que je peux utiliser la version en minuscules comme
en majuscules. De cette façon, je peux modifier ou altérer les colonnes
déjà disponibles. Maintenant, il y a beaucoup plus de
modifications que vous pouvez faire qui dépendent vraiment de
la situation. Selon la
situation dans laquelle vous vous trouvez, vous souhaitez
peut-être
mettre à jour votre base de données
ou vous devez mettre à jour votre base de données et vous souhaitez
modifier ou modifier quelque chose. Hum, le plus simple
à faire est faire
rapidement un rapide
Google et de dire, comment puis-je transformer cela en ceci, et ensuite ce sera exactement la
même syntaxe que celle que nous avions ici. Ce sera soit
quelque chose que vous avez déjà vu, par exemple, modifier les types de colonnes ou
ajouter ou supprimer des colonnes, soit quelque chose de très
similaire, par exemple, modifier une colonne ou
modifier ses contraintes.
13. Types énumérés ci-énumérés: Voyons donc comment créer des types de données énumérés parce que parfois
nous voulons avoir ou qu'il existe un
ordre naturel dans les choses,
mais il est difficile pour nous de le représenter sur un ordinateur Prenons un exemple simple : prenons les jours de la semaine, supposons qu'il y ait
une commande spécifique, et que nous commencions par le lundi
étant le premier jour,
puis que nous puissions passer le mardi, le mercredi, le jeudi, le
vendredi, le samedi, le dimanche, ou
peut-être que vous voulez commencer par dimanche et passer au samedi ou quelle que soit la commande que
vous souhaitez utiliser. Mais peut-être que vous voulez dire
quelque chose comme « je veux uniquement rechercher les cas qui
se produisent après mercredi ». Donc entre le mercredi et le
samedi ou quelque chose comme ça. est difficile d'utiliser cet ordre car il n'est pas inhérent
aux mots eux-mêmes. Nous le savons parce que nous comprenons le sens des jours de la semaine, mais un ordinateur, bien sûr,
ne le sait pas. Une chose que nous pouvons faire en SQL est de créer un type de données
énuméré, dans lequel nous pouvons ensuite spécifier l'ordre hiérarchique entre ces
différentes instances Par exemple, pour ce faire, nous pouvons créer un type, et nous allons avoir le nom de
notre type ici. Nous pouvons
appeler celui-ci, par exemple, le jour de la semaine. Ensuite, nous allons
dire ici sous la forme d'un nombre, c'
est-à-dire sous forme d'énumération,
ouvrir et fermer les
parenthèses, puis avoir un point-virgule à la fin
, juste Nous pouvons maintenant mettre ici l' ordre des différents types. Par exemple, disons que
nous avons d'abord le lundi, puis le mardi. Ensuite, nous avons mercredi ,
puis continuons sur la ligne suivante pour le
rendre plus lisible. Ensuite, nous
aurons jeudi. Ensuite, nous aurons le
vendredi, le samedi et le dimanche. Nous avons maintenant créé un nouveau
type appelé jour de la semaine, qui est un type de données
énuméré, et l'ordre entre
les deux est tel que nous le voyons ici Ce que nous pouvons faire, par exemple, c'est que nous pouvons désormais utiliser ce type
pour créer une autre table. Créons une table. Alors ici, nous pouvons
simplement appeler cette table de test. De cette façon, nous n'avons pas
à nous soucier du nom. Dans ce tableau, utilisons-le pour suivre,
par exemple, les présences. je suppose qu'il aurait mieux valu
appeler « assiduité », mais peu importe.
Laissons les choses comme ça. Ce que nous pouvons suivre
ici, par exemple, c'est un identifiant d'étudiant Faisons en sorte que
ce soit un entier. Ensuite, nous allons également, par
exemple, utiliser le type de données de
notre énumérateur, donc nous pouvons l'appeler
ici le jour de la semaine, ce qui utilisera notre type de données du
jour de la semaine,
puis nous aurons toujours
besoin d'une Appelons simplement cela une clé, et ce sera une clé de série, et ce
sera notre clé primaire. Si nous l'exécutons, ici même, cela nous donne
en fait le choix des
instructions que nous voulons exécuter. Par exemple, si vous n'exécutez que
l'instruction create, nous allons recevoir
une erreur car nous
n'avons pas encore créé le type
numerate Et c'est probablement
parce que nous avons la boîte d'écran ici
qui nous indique que nous allons exécuter
cette section de requête ici. Exécutons cette opération à nouveau
et cette fois, en sélectionnant l'ensemble de l'instruction. Ensuite, si nous cliquons sur Exécuter ou si nous le
sélectionnons et que
nous l'exécutons, nous pouvons voir
que cela fonctionne car il a créé
notre type pour nous. Nous pouvons voir ici que si nous
accédons à notre table de test, nous avons maintenant un
type de données personnalisé, appelé jour de la semaine, que nous avons créé ici, comme
nous pouvons le voir ici. L'important ici
est également que nous ayons le point-virgule à la
fin,
sinon il aurait essayé enchaîner ces commandes De cette façon, nous avons maintenant
différentes requêtes SQL, et il est important de simplement
séparer les différentes requêtes
SQL points-virgules
pour s'assurer qu'elles
ne sont pas
enchaînées ou quelque chose comme ça,
mais qu'elles se mais qu' Ainsi, même si certaines requêtes ou commandes
peuvent être exécutées en série, il est toujours recommandé de les
séparer ,
car d'autres fois vous risquez de rencontrer des problèmes. Il est toujours
recommandé de simplement
séparer ou plutôt de terminer vos
requêtes par un point-virgule De cette façon, l'éditeur de requêtes saura que c'est
la fin de la requête. Ensuite, la prochaine chose
qui arrivera sera le début
d'une nouvelle requête.
14. Inserer des valeurs: Maintenant que nous savons comment
créer et supprimer des tables, ainsi que créer nos types d'énumérateurs
personnalisés et créer des tables avec Voyons comment
insérer des données dans nos tableaux. Pour ce faire, nous allons
utiliser insert into. Ensuite, nous allons avoir
ici le nom de la table. Par exemple,
utilisons notre table de test, puis facultativement, et nous y
reviendrons dans une seconde. Nous pouvons mettre l'ordre des
colonnes ici, mais ignorons cela pour le moment. Ensuite, nous allons utiliser les valeurs
des mots clés. Ensuite, nous allons
ouvrir et fermer les
parenthèses, et encore une fois, pour de bonnes pratiques,
placer le point-virgule à la fin de la requête ici Nous allons maintenant saisir
les valeurs que nous voulons insérer. Désormais, par défaut, les
valeurs seront dans l'ordre dans lequel nous les avons
également mises ici. Par exemple, nous avons une carte d'
étudiant et un jour de semaine. Comme notre clé ici
est en fait une série, nous n'avons pas besoin de
fournir de valeur pour celle-ci. Supposons que notre numéro d'
étudiant soit un et valeur
du jour de la semaine
soit le lundi Ensuite, nous pouvons exécuter ceci et
ensuite il va être inséré. Il a publié l'intégralité de la déclaration. Il va
insérer dans notre table de test
les valeurs 1 et Monday.
Comment pouvons-nous le voir ? Eh bien, nous pouvons simplement
double-cliquer sur notre tableau ici et cela l'
ouvrira dans un nouvel onglet. Ici, nous pouvons voir que nous
avons le numéro d'étudiant. jour de la semaine est le lundi, et nous avons également notre clé ici, qui a été créée automatiquement pour nous Maintenant, nous pouvons également spécifier l'ordre des
colonnes ici si nous le voulons. Par exemple, peut-être
voulons-nous d'abord insérer le jour de la semaine, puis ensuite, le numéro
d'étudiant De cette façon, nous devons
modifier l'ordre ici. Disons que pour mardi, nous avons encore un étudiant. Mais cette fois, remarquez que l'ordre des
colonnes est différent. Nous avons choisi ou nous avons choisi notre commande personnalisée que nous voulons utiliser
pour l'
insérer dans ce tableau. Mais il est important que nous
suivions cette commande personnalisée. Sinon, le tableau
supposera que nous utilisons l'ordre
par défaut, et c'est également ainsi qu'il
va insérer les valeurs. Une autre chose importante
que je tiens également à souligner est qu'
il est important ici que nous utilisions des
guillemets simples plutôt
que des guillemets
doubles. Je vais expliquer pourquoi dans une seconde. Allons-y et exécutons-le. Nous allons exécuter l'ensemble
de la requête. Il va être
inséré dans notre tableau ici. Laissez-moi le fermer et le rouvrir. Il va être
inséré dans notre tableau. Encore une fois, nous avons notre numéro d'
étudiant. Le jour de semaine est
maintenant mardi, est exactement ce que
nous avons indiqué ici Maintenant, si nous
ne voulons pas utiliser guillemets
doubles, c'est parce que guillemets
doubles sont
utilisés pour les noms de colonnes. Parfois, nous pouvons avoir des noms de
colonnes qui peuvent entrer en conflit
avec autre chose dans SQL. Pour indiquer qu'un
élément est une colonne, nous pouvons également l'entourer de
guillemets doubles. Par exemple,
utilisons le mercredi ici. Utilisons ici les guillemets
doubles pour indiquer qu'il s'
agit de colonnes. Encore une fois, ce
sera pour la première carte d'étudiant. Encore une fois, parce que c'est ainsi que nous spécifions actuellement l'
ordre des colonnes. Si nous allons de l'avant et que nous procédons
ainsi, je me
trompe en ce moment parce que mon orthographe du
mercredi est incorrecte. Jetons un coup d'œil à notre jour
de la semaine et à notre type de données, et je vais juste voir. Il y avait un espace supplémentaire ici. Eh bien,
laissons les choses telles quelles pour le moment. Nous avons juste besoin de mettre un espace
supplémentaire devant. Ici, bien sûr,
vous pouvez également voir ce qui se passe, et c'est en fait ce que
j'allais aborder ensuite. Mais vous pouvez voir ce qui se passe
si vous entrez ici une valeur dans un type de
données énuméré qui n'appartient pas au type de
données lui-même En utilisant maintenant le formatage
approprié, allons-y une fois de plus,
puis jetons un
coup d'œil à notre tableau OK.
Regardez un tableau ici. Si nous le voulons, nous pouvons le
fermer et le rouvrir. autre chose que nous
pouvons faire est de simplement appuyer sur le bouton d'actualisation ici et cela actualisera notre
tableau comme nous pouvons le voir ici, nous pouvons le constater lorsque nous
revenons à notre console, en utilisant les
guillemets doubles ici. Spécifiez à nouveau la colonne. En utilisant un simple
guillemet, spécifiez la valeur
que nous voulons insérer. Si nous mettons ici des
guillemets doubles, par exemple, utilisons jeudi ici, mais dans ce cas, nous allons utiliser des guillemets
doubles. Nous pouvons déjà voir par le
code couleur que cela va échouer. Et fermons ça. Mais essayons quand même. Allons-y, exécutons-le et courons pour voir
qu'il est écrit ici la colonne « jeudi »
n'existe pas. Encore une fois, les
guillemets doubles représentent quatre colonnes. Les guillemets simples sont destinés aux chaînes de texte. Si nous l'exécutons maintenant, en insérant ici et en rechargeant
simplement notre page, nous pouvons voir ici à nouveau que
nous avons inséré nos données Que se passe-t-il si
nous voulons mettre à jour type que nous utilisons puisque nous avons maintenant un peu foiré
notre type Maintenant, ce que nous pouvons faire
pour cela
, c'est simplement revoir nos
types ici. La syntaxe que nous allons
utiliser, nous allons dire, modifier le type, et nous allons
modifier notre jour de la semaine. Nous allons dire renommer la valeur, et nous allons renommer
le mercredi 2, Sam Colon ici Exécutons, jetons un
coup d'œil à notre type et
actualisons-le. Nous pouvons donc voir ici que notre
type a été mis à jour. Je constate la même
erreur ici dimanche. Allons-y et
faisons-le également pour le dimanche. Dimanche et nous allons le
renommer en dimanche. Allons-y et exécutons-le. Revenez à nos types ici, en rechargeant, et nous verrons qu'un dimanche a
également été corrigé Si nous examinons l'actualisation de
notre base de données, nous pouvons voir
que la valeur de notre base de données a également été mise à jour de
manière appropriée. Nous avons maintenant vu comment
insérer des données dans notre base de données. Aussi, comment pouvons-nous modifier
le type si nous le voulons. Bien entendu, une autre option est si vous partez de zéro, si vous avez une base de données complètement
propre, vous pouvez également simplement
supprimer la table et créer le type à partir de zéro, puis continuer avec
le type correct. Bien entendu, il existe
différentes options pour résoudre le même problème.
15. Gérer un script SQL: Maintenant, comme vous pouvez le
constater, l'insertion de données dans nos tables peut être
un peu fastidieuse, notamment parce qu'en SQL, nous devons les insérer
une valeur à la fois C'est généralement la raison pour laquelle les données dans les tables
SQL sont insérées
par l'arrière là où les choses sont configurées avec les autres pipelines et chaque fois que les données nécessaires
y parviennent ou y passent, elles sont ensuite téléchargées
dans la base de données. L'utilisation des instructions d'
insertion dans les instructions n'est pas particulièrement efficace si, en
tant qu'utilisateur, vous devez le faire parce que vous devez tout
écrire. Il est beaucoup plus efficace de le
faire dans le cadre
du code qui fait partie de vos pipelines
de données
afin que vous puissiez ensuite simplement télécharger les
données dans la base de données. Donc, la plupart du temps, vous n'allez pas réellement
insérer de données Si vous l'utilisez pour effectuer des requêtes soit
pour explorer vos données, pour les analyser,
soit pour les exporter afin d'exécuter votre propre analyse personnalisée,
soit
pour effectuer d'autres tâches avec elles Soyez conscient de cela. Il existe maintenant des moyens d'
insérer des données plus rapidement. Par exemple, si nous accédions aux informations de notre
événement et que insérons dans les informations de l'événement, et que nous voulons insérer les valeurs et simplement en donner une idée et un nom, par exemple ,
login, alors si nous pouvons l'
exécuter ou si nous voulons réellement saisir plusieurs
valeurs à la fois, par
exemple, deux ici
seront cliquées. Ensuite, comme vous pouvez
le voir pour les valeurs d'insertion, nous pouvons simplement les séparer
par des virgules
, puis chaque ligne ou chaque enregistrement que nous voulons insérer ici se
trouve entre parenthèses Nous pouvons, par exemple,
insérer deux valeurs. Jetons un coup d'œil à
notre tableau d'informations sur les événements. Actuellement, il est vide. Si nous l'exécutons, puis que nous jetons un coup d'œil et que nous actualisons notre tableau, nous pouvons voir que nous avons inséré
deux valeurs à la fois. Mais même cela n'est pas
particulièrement efficace. Encore une fois, la plupart
du temps,
cela se fera du côté principal lorsque vos données passeront
par les pipelines de données par les pipelines car tout cela
peut être automatisé, ce qui est extrêmement
intéressant, car
votre base de données ne cesse de
se remplir de
données au fur
et votre base de données ne cesse de
se à mesure que vos pipelines de données traitent
les données
ou les déplacent. Maintenant, pour nous, ce que nous allons
faire, c'est utiliser une base de données ouverte avec laquelle nous
pouvons jouer. Avant cela,
allons-y et abandonnons toutes nos tables. Nous allons dire « drop restons-en à la syntaxe des
majuscules ici. Nous allons supprimer
le tableau d'informations sur l'événement. Allons-y et exécutons-le. Dans ce cas, parce que
nous avons lié notre
journal des événements aux informations sur les événements à l'
aide d'une clé étrangère. Si vous vous souvenez de la façon dont nous avons créé le journal des événements, nous
avons un lien ici. Vers les informations de l'événement
avec la clé étrangère. Nous allons également utiliser l'instruction
cascade pour effectuer cette série continue
de suppressions où se trouvent toutes ces références
. Je gère ça. Cela va supprimer notre tableau d'informations sur les
événements pour nous. Ensuite, nous pouvons faire la même chose
pour les informations utilisateur, encore une fois, l'événement en
cascade car il est toujours lié
dans le journal des événements, puis nous pouvons
supprimer le journal des événements Ici, nous n'avons plus besoin de mettre quoi que ce soit en
cascade car cela
n'est plus lié à rien. Allons-y et retirons-le. Ensuite, nous pouvons également
supprimer la table de test. Allons-y et retirons-le. Ensuite, nous pouvons également fermer notre touche supplémentaire ici car
elle n'est plus pertinente. Nous allons
revenir à la gestion des données,
et nous allons simplement effacer
notre éditeur de requêtes ici pour accéder à notre console de requêtes. Pour obtenir nos nouvelles données, nous allons accéder
à cette page de configuration de la base sur les chinooks Incluez un lien vers celui-ci
dans l'onglet des matériaux, afin que vous puissiez également le
référencer à partir de là. Pour obtenir ces données, il va
s'agir d'une requête SQL que nous pouvons exécuter, vous pouvez simplement cliquer sur Télécharger ici, d'une requête SQL que nous pouvons exécuter,
vous pouvez simplement cliquer sur Télécharger ici,
et soit le téléchargement sera
gratuit directement, soit comme cela a été le cas pour moi, il s'ouvrira dans une
seconde, si je clique dessus Il va l'ouvrir
ici dans un nouvel onglet et vous pouvez voir ici que tout cela est
en fait des instructions SQL. Encore une fois, si vous avez du SQL ou si vous avez du SQL, la table est
intégrée à votre entreprise. La plupart du temps,
il ne
sera toujours pas inséré à
l'aide d'instructions SQL, mais il sera
connecté directement à la table SQL. Mais quoi qu'il en soit. Ici, tout
cela va être fait pour nous
en utilisant des requêtes SQL. Si vous le souhaitez, vous pouvez
également y jeter un
œil pour voir ce
qu'il fait réellement. Mais si vous souhaitez
ensuite utiliser cette requête, vous allez cliquer ici avec
le bouton droit de la souris. OK. Vous allez cliquer avec
le bouton droit de la souris, puis cliquer sur Enregistrer. Ensuite, je l'ai enregistré
sur le bureau, comme vous pouvez déjà le voir. Assurez-vous simplement de supprimer
l'extension TXT
à points afin que nous puissions
l'utiliser dans une seconde. Ensuite, il suffit de cliquer sur Enregistrer. Bien entendu,
vous pouvez également l'
enregistrer où vous le souhaitez. Je l'ai déjà fait.
Pour exécuter cette requête SQL ou la série de
requêtes SQL que nous
venons de télécharger et
les ajouter à notre base de données. Nous allons
cliquer avec le bouton droit sur notre schéma ici. Ensuite, nous allons lancer
ici un script SQL. Nous allons choisir
ce script SQL ici. Nous allons appuyer sur Ouvrir,
puis il va
l'exécuter pour nous. Nous pouvons simplement
attendre que tout soit terminé, ce qui ne prendra que
quelques secondes. Nous pouvons voir ici
que c'est fait, cela nous a permis de créer de nouvelles tables. Nous pouvons jeter un œil à chacune d'elles si nous voulons et simplement les
explorer un peu, ou vous pouvez également les
consulter directement ici. Nous avons maintenant des données que
nous pouvons utiliser et qui sont en fait bien plus que ce que
nous
aurions pu insérer manuellement. Si vous souhaitez ouvrir
l'éditeur
de requêtes parce qu'il a été révélé
par accident. Encore une fois, nous savons comment procéder. C'est ainsi que nous pouvons
également exécuter des scripts SQL, si nous le voulons, ce qui, dans ce cas, nous permet
simplement de créer une
pratique ou d'utiliser une base de données d'entraînement
que nous pouvons ensuite utiliser pour des requêtes supplémentaires Encore une fois, bien sûr, si
vous devez travailler avec une
base de données d'entreprise ou autre, la base
de données est déjà remplie. Ainsi, lorsque vous l'interrogerez, vous devez simplement vous concentrer sur
votre analyse ou sur la recherche des données
nécessaires que vous pouvez extraire pour effectuer d'
autres tâches Étant donné que le téléchargement
se fera principalement dans les pipelines
de données il sera
beaucoup plus efficace de tout
mettre à jour automatiquement dans le cadre
des pipelines
16. Lire des données: C'est bon. Maintenant que nos tables sont à notre disposition,
voyons comment nous pouvons réellement obtenir des données
à partir de nos tables. Allons-y et jetons un coup d'œil au premier tableau ici, celui sur les albums appelé album. Si nous jetons un coup d'œil ici, nous voyons que nous avons plusieurs colonnes
différentes, plusieurs attributs différents,
nous avons l'identifiant de l'album. Nous avons le titre,
ainsi qu'un identifiant d'artiste. Nous avons
ici différents albums réalisés par
différents artistes, et chaque album, bien sûr, possède
également son propre identifiant unique. Comment pouvons-nous obtenir des données à partir d'ici ? Comment lire les données de cette table à
l'aide d'une requête SQL ? Nous allons
revenir à notre console, assurant que
nous sommes connectés à notre bonne source de données ici
en utilisant cette console appropriée. Maintenant, pour obtenir les données de notre table, nous allons dire « sélectionner ». Ensuite, nous allons dire étoile,
ce qui signifie tout. Sélectionnez toutes les colonnes. Ensuite, nous voulons faire une sélection
dans l'album. Maintenant, si j'appuie sur Entrée ici
et que je le laisse se terminer automatiquement, vous verrez que nous
avons des
guillemets ici. Nous en
parlerons et nous
parlerons également de cette étoile ici, ainsi que de la façon dont nous pouvons
modifier ces choses. Mais tout d'abord,
exécutons-le et voyons les
résultats que nous obtenons. Si nous l'exécutons, nous pouvons voir ici que ce sont les résultats que
nous obtenons de notre requête. Nous pouvons voir que nous avons sélectionné
trois colonnes différentes. Nous avons l'
identifiant de l'album, le titre, ainsi que l'
identifiant de l'artiste, et nous pouvons voir ici nous pouvons faire défiler l'écran vers le bas et sélectionner un tas de
données ou, dans ce
cas, toutes nos données
de notre tableau d'albums ici. Examinons d'abord ces guillemets, car plupart du temps, dans les requêtes SQL, de vos tables ne seront
pas noms de vos tables ne seront
pas
entourés de guillemets. D'où cela
vient-il ? Eh bien, si nous examinons le
script SQL que nous avons exécuté, nous pouvons voir ici l'
instruction create table qu'ils ont utilisée, mettre des guillemets
autour du nom de la table, ce qui signifie que nous devons maintenant y
faire référence en utilisant des guillemets. Si j'ai supprimé les
guillemets, vous pouvez déjà voir
ici qu'il devient rouge, mais nous pouvons quand même essayer de l'exécuter. Nous allons recevoir
une erreur car elle indique que la table n'existe pas. Comment pouvons-nous changer cela car ce n'est pas très agréable de toujours le
mettre entre guillemets. Pour mettre cela à jour, nous allons à
nouveau utiliser l'instruction alter table, et nous allons
modifier l'album, encore une fois, en le
mettant entre guillemets ici, puis
nous allons dire renommer deux, et maintenant nous
allons simplement l'appeler album
sans les guillemets Allons-y et exécutons-le. Maintenant, allons-y et écrivons
la même instruction de sélection, sélectionnez l'étoile dans l'album. Mais cette fois, nous n'
allons pas mettre de
guillemets ici. Si nous l'exécutons, vous pouvez constater que cette fois, nous n'
avons aucun problème, car nous avons maintenant renommé
notre table pour passer
des guillemets à un nom de table sans
guillemets, ce qui est beaucoup
plus pratique car nous n'avons pas à toujours tout
mettre entre
guillemets. Dans certains cas, cela peut être
dû au fait que l' instruction create
table,
comme nous pouvons le voir ici, comportait guillemets dans l'instruction create table
d'origine. Parlons également de
cette étoile ici. Ce que nous mettons ici, ce sont
les colonnes que nous voulons sélectionner dans notre tableau. Dans ce cas, nous mettons une étoile, cela signifie sélectionner
chaque colonne. Parfois, nous ne voulons pas
sélectionner chaque colonne. Et si parfois
nous voulions simplement
sélectionner un sous-ensemble de colonnes Disons que nous ne nous soucions que de
l'identifiant et du titre de l'album. Nous ne voulons pas
extraire l'artiste. Eh bien, ce que nous pouvons faire, c'est dire de
sélectionner l'identifiant de l'album, et nous allons également
sélectionner le titre. Extrait de l'album. Encore une fois, vous verrez que je dois mettre des
guillemets, et encore une fois, le
remplissage automatique de Data Grip l'a fait pour moi. Encore une fois, c'est simplement parce que si
nous examinons notre requête SQL ici, nous pouvons voir que
les noms des tables ont également été créés à
l'aide de guillemets. Si nous revenons en arrière, nous
pouvons le voir encore une fois, nous devons également utiliser des
guillemets ou des noms de tables. Si nous l'exécutons, nous
pouvons voir ici nos résultats mis à jour ne
contiennent plus l'identifiant de l'artiste, que nous avons ici. Mais à la place, nous avons l'
identifiant de l'album ainsi que le titre. Maintenant, nous pouvons également, bien sûr, modifier l'ordre ici. Au lieu d'avoir d'abord
l'identifiant de l'album, nous pouvons peut-être
lire le titre, puis l'identifiant de l'album,
donc si nous l'exécutons, nous pouvons voir
ici que
le résultat de l'ordre de nos colonnes sera
également inversé Après l'instruction de sélection ici, nous sélectionnons les colonnes que nous voulons. Si nous voulons sélectionner toutes les
colonnes, nous mettons une étoile. Si nous voulons sélectionner
des colonnes spécifiques, nous devons mettre leur nom ici. instruction Create table
n'utilise pas guillemets pour
définir les noms des colonnes, nous n'avons
donc pas non
plus à les utiliser ici. Mais dans ce cas, ils le font, ce qui signifie que nous devons également les
utiliser dans notre code. Parfois, lorsque vous explorez
simplement une base de données ou que vous rédigez
une requête et que vous souhaitez voir les
résultats de la requête, mais que vous ne voulez pas que
tout soit renvoyé car renvoyer
toutes les données, en particulier s'il y a beaucoup de données dans votre base
de données, demande beaucoup de travail. Il y a une instruction supplémentaire
que nous pouvons mettre à la fin de notre requête appelée mit. Cela limite le nombre de lignes qui nous sont renvoyées et
qui apparaîtront réellement. Par exemple, si je mets cinq, cela signifie que nous n'allons
voir que cinq lignes ici. Ce seront les cinq
premières rangées. Si nous l'exécutons, nous
pouvons voir ici que seules les cinq premières
lignes nous sont renvoyées. Si je limite deux, seules les deux
premières lignes
seront affichées. Si j'en fais 50, cela nous donnera
les 50 premières lignes. De cette façon, vous pouvez également gérer le nombre de
valeurs
renvoyées, que vous pouvez soit utiliser
dans les requêtes si vous le souhaitez je ne sais pas si vous effectuez filtrage personnalisé spécifique, soit vous pouvez également l'utiliser
lorsque vous testez vos requêtes et que vous ne
voulez pas que toutes les valeurs soient renvoyées, mais vous voulez simplement vous assurer que cela fonctionne correctement, et donc vous ne
voulez que quelques valeurs, vous voulez limiter
vos résultats à quelques lignes afin de
pouvoir les examiner, vous
assurer qu' ils fonctionnent
correctement ou peut-être détecter des erreurs,
corriger votre requête,
réessayer, puis
jusqu'à ce qu'elle fonctionne, puis vous pouvez également à nouveau supprimer l'instruction limit, si vous souhaitez l'exécuter
sur l'
ensemble de données complet ou plutôt si vous souhaitez que
tous les enregistrements soient renvoyés.
17. Créer des tables à partir de résultats de la recherche: Dans la leçon précédente,
nous avons donc appris comment lire données de nos tables
au sein de notre base de données. Voyons maintenant
comment créer de
nouvelles tables à partir des résultats car parfois
vous écrivez une requête,
puis vous souhaitez
enregistrer ces résultats dans une table séparée afin de
pouvoir
y accéder rapidement à des fins de visualisation
après avoir effectué traitement
des données ou
peut-être l'utiliser ailleurs. Il peut donc y avoir, bien sûr, des situations dans lesquelles vous souhaitez stocker les résultats
de votre requête dans une table séparée pour une utilisation
ultérieure. Comment pouvons-nous le faire ? Pour ce faire, nous allons
d'abord mettre ici, créer une table, puis nous allons
avoir le nom de la table. Oh. Créez une table, et nous
allons avoir le nom de la table. Peut-être que nous appelons cet
album des résultats, puis que nous allons dire comme, puis nous allons
mettre entre parenthèses notre
déclaration de sélection comme ceci Cela signifie que
nous allons créer un tableau et
utiliser les résultats d'ici. Vous remarquerez maintenant que nous ne
définissons aucune
des colonnes ou que nous ne définissons également aucun de
leurs types de données. Tout cela sera
déduit résultats
de notre requête ici Si on l'exécute, alors il suffit de garder un œil sur
le côté gauche. Nous pouvons voir que nous avons maintenant
notre tableau des résultats des albums, qui est, comme nous pouvons le voir, juste les résultats de notre requête ici et il sera identique à notre tableau des albums car c'est encore une fois ce que nous
avons renvoyé d'ici. Nous pouvons également y jeter un œil
si nous le voulons. Nous pouvons simplement jeter un
œil à l'intérieur, nous pouvons voir que les
types sont déduits Une chose que nous remarquons est qu'aucune
clé primaire n'est définie ici. La clé primaire, ainsi que keelings étrangers
potentiels,
ne sont pas repris dans
notre nouveau tableau ici Mais nous pouvons toujours
utiliser les résultats de nos requêtes, puis
les enregistrer dans des tables séparées afin
de pouvoir ensuite utiliser ces résultats nous le souhaitons
spécifiquement. Maintenant, comme vous m'avez vu
le faire plusieurs fois, j'ai commencé à étendre
nos requêtes sur plusieurs lignes juste pour en
faciliter la lecture. Parfois, il est tout à fait normal exécuter toute cette requête en une seule fois, mais dans d'autres cas,
cela peut ne pas fonctionner ou ne pas être optimal car cela
deviendra vraiment très long. Vous pouvez bien entendu
diviser votre requête sur
plusieurs lignes, ce qui en
facilitera également la lecture. En général, vous souhaitez le
diviser sur des points clés spécifiques. Par exemple, si vous effectuez une sélection
parmi différentes colonnes, vous souhaitez
généralement que
l'instruction from figure également sur une nouvelle ligne, et nous pouvons effectuer un ordre
approprié ici. Nous voulons créer une table et
avoir le nom de la table ici, puis nous pouvons placer
notre requête ici. Si vous souhaitez
sélectionner, par exemple, des colonnes spécifiques
telles que l'identifiant de l'album. Ensuite, sur la ligne suivante, nous pouvons avoir, par exemple, le titre afin que
cette méthode devienne beaucoup plus lisible et qu'elle ne
s'étende pas très longtemps
dans l'horizontale. Que se passera-t-il si
nous
réexécutons cette requête ? Je gère le tout. Cette fois, nous
allons encore une fois faire erreur car notre table existe
déjà. Ce que nous pouvons faire, c'est modifier notre instruction de création de
table ici, et nous pouvons dire, créer une
table si elle n'existe pas. Cela fonctionne maintenant pour l'instruction create table qui utilise le résultat de
l'instruction select, mais cela fonctionne également pour notre instruction
générale create table. Rappelez-vous quand nous avons créé
notre table puis que nous avons fourni
le nom de la table, et que nous avons défini chaque colonne ainsi que chaque
type, ainsi que les clés
primaires et les références de clés
étrangères ainsi que peut-être
d'autres contraintes. Là, nous pouvons également utiliser
create table si elle n'existe pas. L'avantage
est que cela n'exécutera l'instruction ou essaiera de créer
la table
que si elle
n'existe pas déjà. Dans ce cas, il n'y aura
pas le problème d'entrer en conflit avec une table
déjà existante Maintenant, une autre chose que
je veux également aborder est
de savoir comment
accéder aux noms de tables. Supprimons cela à nouveau, et nous allons simplement tout
sélectionner. Maintenant, nous faisons du
cerceau. Revenons ici. Actuellement, nous sélectionnons
tout dans l'album, et nous déduisons
quelle table nous voulons, car nous sommes déjà dans la base de données
et dans le schéma Mais parfois, nous pouvons avoir plusieurs bases de données
ou plusieurs schémas Comment pouvons-nous
référencer spécifiquement la table exacte que nous voulons si nous avons plusieurs bases de données ici
ou plusieurs schémas. Nous pouvons également fournir
le chemin complet
vers notre base de données ou
plutôt vers notre table. Nous pouvons dire que nous voulons partir de RDB pour
choisir le schéma public Et ici, nous voulons
choisir l'album. Si nous cliquons sur Exécuter maintenant, vous pouvez voir que cela fonctionne
toujours pleinement. Mais dans ce cas,
nous faisons référence au chemin complet vers notre table. Maintenant, c'est, bien sûr, utile. Encore une fois, si nous avons plusieurs schémas
différents ou plusieurs
bases de données différentes,
nous pouvons toujours nous
assurer que si les noms des tables sont répétitifs, nous
référençons les bonnes Je peux aussi faire la même chose. Supprimons, par exemple, tableau des résultats des albums
que nous avons créé. Nous allons dire supprimer le tableau, et nous allons supprimer le tableau
des
résultats de l'album en utilisant le chemin de référence
complet. Nous pourrions également l'utiliser uniquement
avec ce composant ici, mais nous pouvons également utiliser le chemin de référence
complet. Si nous l'exécutons, nous
pouvons voir notre tableau
être supprimé, et nous pouvons également constater que notre
data grip le met à jour et indique en
gros que ce n'
est pas défini. Il s'agit d'une référence inconnue. Nous pouvons voir que nous pouvons utiliser à la fois des chemins absolus
et des chemins relatifs, en grande partie liés à la
facilité de mise en œuvre. Dans notre cas, par exemple, lorsque
nous n'avons qu'une seule base de données, un
seul schéma contenant un
tas de tables,
il sera beaucoup
plus facile de simplement référencer directement
la table
plutôt que de mettre le chemin complet. Mais au fur et à mesure que votre base de données s'agrandit
ou que vous obtenez de nouveaux schémas , ou peut-être que l'entreprise possède déjà plusieurs bases de données
ou plusieurs schémas différents L'utilisation de ces
chemins absolus peut être utile
car elle
garantit que vous référencez les bonnes tables
18. 16asingAliasingAndordorduresHB: Parfois, lorsque nous exécutons des requêtes ou lorsque nous essayons de supprimer des colonnes spécifiques font référence à des tables spécifiques. Les noms peuvent devenir très longs. Donc, une chose que je veux examiner maintenant est d'utiliser alias pour les noms afin que nous puissions raccourcir les noms que nous utilisons dans nos requêtes. Jetons un coup d'oeil à la table des employés. Je l'ai déjà ouvert ici. Nous pouvons faire défiler les différentes colonnes à notre disposition. Et sortons juste trois colonnes ici. Sortons le Prénom, le Nom, et sortons également leur email. Donc, nous allons dire sélectionner le prénom et ensuite nous allons sélectionner le nom de famille. Et nous allons également sélectionner l'e-mail dans la table des employés. J' ai raison. Et donc nous allons juste mettre notre point-virgule ici. Et limitons encore nos résultats. Mais mettons aussi un peu de structure ici. Donc r de l'instruction va être sur une nouvelle ligne. Notre limite sera sur une nouvelle ligne, et chacune de nos colonnes sera également sur une nouvelle ligne. Donc, cela va juste le rendre plus lisible comme la requête, peut-être qu'il est plus grand. Et nous allons aussi, bien sûr, mettre un numéro ici quand nous limitons notre déclaration. Donc, si nous faisons ça, nous pouvons voir ici ce sont nos résultats. Et vous remarquerez que dans ce cas, nous devons toujours mettre guillemets autour
du nom de la table parce que je n'ai pas mis à jour le nom de la table ici. Et notre colonne nécessite toujours des guillemets. Maintenant, lorsque nos colonnes sont créées sans guillemets, nous pouvons toujours les utiliser pour ne connaître aucun nom de colonne, mais ce n'est pas nécessaire. Dans ce cas. C'est vraiment nécessaire pour nous parce qu' il a été créé avec les guillemets. Et donc si nous nous souvenons, si nous les
enlevons, nous allons rencontrer un problème parce que notre table a été créée avec des guillemets autour. Néanmoins, l'utilisation de guillemets autour des noms de
colonnes est en fait assez agréable car il est beaucoup plus facile voir ce que la colonne ou ceux qui sont appelés les noms et lesquels sont d'autres choses. Donc, garder des guillemets autour des noms de colonnes n'est pas vraiment trop mauvais, mais c'est le cas, et c'est aussi les noms de table Kieran, mais cela devient un peu fastidieux pour l'utilisateur sur deux ammoniums. Donc, si vous voulez faire cela, vous pouvez bien sûr, comme nous l'avons vu dans les leçons précédentes, juste modifier le nom de la table ici et vous n'avez plus besoin
d'utiliser les guillemets autour. Bon, alors comment pouvons-nous ajouter des alias ou des colonnes ? Par exemple, disons que nous voulons que notre colonne de sortie ne soit pas appelée FirstName, mais plutôt que nous voulions lui donner autre chose. Par exemple, disons que nous voulons juste utiliser la colonne de sortie ici pour être en premier. Et nous voulons que notre nom de famille soit appelé en dernier. Et nous voulons que l'e-mail reste comme e-mail afin que nous ne les modifiions pas. Donc, si nous exécutons ceci, nous pouvons voir ici maintenant notre sortie est la première et la dernière, et notre email est resté le même. Donc, nous pouvons voir ici nous pouvons assigner des alias à nos noms de colonnes, et cela va réellement les changer dans les réponses résultantes que nous avons obtenu. Et plus tard, à mesure que les requêtes s'
agrandissent, nous pouvons également référencer ou les noms de table en utilisant les alias que nous leur assignons ici, plutôt que d'utiliser le nom complet. Mais ce n'est pas seulement pour les colonnes que nous pouvons attribuer des alias, nous pouvons également le faire pour les tables. Donc, pour assigner un alias à une table, nous allons juste mettre un espace ici. Et puis nous mettrions juste l'alias que nous voulons utiliser. Par exemple, si nous voulons raccourcir pour l'employé, qui peut être utiliser MP. Et cela signifie que nous pouvons maintenant utiliser MP pour référencer l'employé. Donc, un endroit où vous pouvez le faire est, par exemple, parfois lorsque vous traitez de plusieurs tables dans la même requête, et peut-être que certaines des colonnes sont les mêmes colonnes sur plusieurs tables différentes. Vous voulez vous assurer que vous référentez la colonne de droite à partir de la table de droite. Donc, tout comme nous l'avons vu quand nous
sélectionnions à partir d'une table et nous avons donné le chemin complet à la table. On peut faire la même chose pour les colonnes. Ainsi, par exemple, nous pouvons ensuite référencer notre table et ici, et nous pouvons dire m point prénom. Vous pouvez dire m dot nom de famille. Et nous pouvons dire m dot email. Et donc si on fait ça, on voit que ça marche. Nous voyons donc que nos résultats ne vont pas changer. Mais la façon dont nous écrivons notre requête le fait parce que nous référençons maintenant les choses différemment. Donc, nous pouvons voir ici, c'est ainsi que nous donnons des alias à nos noms de colonnes en utilisant le mot-clé as. Mais si nous voulons donner un alias à un nom de table, nous pouvons juste mettre un espace après avoir l'instruction frontale ici dans le nom de la table. Et puis nous mettons l'alias que nous voulons donner au nom de la table. Et cela nous permet juste d'utiliser cet alias tout au long notre requête afin que nous
référentions cette table plutôt que d'avoir à écrire le nom complet de la table. Bien sûr, dans ce cas, cela peut sembler un peu inutile juste parce que nous pouvons déjà extraire les colonnes comme ceci. Mais quand vous avez plusieurs tables différentes dans la même requête, cela peut être vraiment agréable. Pour vous assurer que lorsqu'il y a différentes colonnes, sont des colonnes identiques dans les différentes tables que vous référentez la colonne de droite de la table de droite. Et donc c'est aussi alors comment nous pouvons utiliser le raccourci de la table que nous utilisons. Et nous pouvons l'utiliser, par exemple, pour accéder
aux attributs de colonne à l'intérieur pour nous assurer que nous
accédons à la colonne à partir de cette table spécifique, qui est un raccourci pour cette table ici. Maintenant, une autre chose que je veux aussi aller sur est de commander des résultats. Donc en ce moment, la façon dont nos résultats sont retournés est juste par la façon dont ils sont insérés ici. Donc nous pouvons voir que nous avons l'ordre ici. Et c'est aussi exactement comme ça qu'ils vont nous être rendus ici. Mais parfois, nous voulons réellement commander des choses, soit commander dans le cadre de la requête, puis faire autre chose plus tard, ou simplement avoir les résultats finaux ordonnés. Donc, pour ce faire, nous allons utiliser l'instruction order BY avec 1D ici. D' accord, donc l'ordre BY nous pouvons maintenant mettre dans les noms de colonne ou l'emplacement de la colonne. Nous allons regarder les deux et ensuite nous pouvons commander par ceux-là. Donc, disons que nous voulons d'abord commander par le prénom, puis par le nom de famille. Et puis nous voulons retourner nos résultats. Et nous voulons commander dans l'ordre croissant afin que ce qui
est le plus bas soit le premier et ensuite nous irons dans l'ordre croissant. Donc, pour commander d'abord par le prénom, nous pouvons ensuite mettre ici d'abord, qui va faire référence, dans ce cas, à l'alias de colonne que nous avons utilisé ici. Ensuite, nous allons passer commande par la dernière fois. Et maintenant, nous voulons aussi dire que ces deux devraient être ordonnés dans l'ordre croissant, ce qui sera en fait la valeur par défaut. Mais faisons-le comme ça d'abord. Et puis nous mettrons spécifiquement l'ordre croissant. Donc, nous exécutons cette requête. Et nous pouvons voir que nous sommes en train de commander dans un ordre croissant de prénom d'abord, puis dans le cas où il y aurait un prénom temporel, qui dans ce cas il ne semble pas qu'il y ait pour eux et utiliser le nom de famille pour commander. Donc, pour vérifier cela, nous pouvons également aller dans notre table, qui est en fait assez petite comme vous pouvez le voir. Et nous pouvons aussi simplement cliquer sur la commande par prénom ici. Et nous verrons que nous allons obtenir la même commande que nous arrivons ici. Donc, encore une fois, l'instruction order BY est l'ordre par lequel nous voulons commander les colonnes à partir de. Donc, nous allons d'abord commander par la première colonne ici, qui est notre alias pour la colonne FirstName. Au cas où il y aurait une égalité, nous allons alors utiliser cette dernière colonne, qui est notre alias pour la colonne de nom de famille. Dans ce cas, nous n'avons pas de liens, donc ça ne fait rien. Et puis après cela, il n'y a pas de commande spécifique que nous utilisons. Donc, il va le faire au cas où il y aurait plus de liens, juste retour par défaut à
la frontière, l'ordre naturel des données dans notre table. Maintenant, pour spécifier explicitement que nous voulons utiliser l'ordre croissant, nous pouvons mettre ASC ici, et nous pouvons mettre ASC ici. Pour qu'on puisse recommencer ça. Maintenant, nos résultats ne vont pas changer car il est également par défaut ASC. Mais vous pouvez voir après chaque colonne que nous avons dans cet ordre BY clause ici, nous pouvons également spécifier l'ordre que nous voulons faire, soit croissant ou descendant. Donc, si nous voulons d'abord commander le prénom dans l'ordre décroissant, puis en cas de liens, utilisez le nom de famille dans l'ordre croissant. Nous pouvons spécifier descendant comme ceci, et ensuite nous pouvons laisser le LastName comme ascendant comme ceci. Donc, si nous exécutons ceci, maintenant nos résultats vont changer parce que nous utilisons le FirstName en premier, et nous sommes en ordre décroissant, ce qui signifie le plus haut en premier pour les grandes urnes alphabétiques plus proches de zed. Et puis en cas de liens, auquel cas il n'y
en a pas actuellement, nous allons utiliser le nom de famille. Donc, dans ce cas encore, le nom de famille n'est pas utilisé, mais l'ordre va passer d'abord par ordre de prénom, descendant, donc le plus haut d'abord, puis Lois tout en bas. Et en cas de liens, utilisez le nom de famille, puis triez les colonnes qui ont des liens sur le
prénom, nom de famille, mais utilisez ici un ordre croissant. Et comme vous pouvez le voir, nous pouvons spécifier l'ordre spécifique que nous voulons utiliser pour chaque colonne que nous voulons commander BY. Et puis nous pouvons également commander par, par exemple, et la colonne e-mail ici. Si on veut. Nous pouvons également commander des colonnes BY que nous ne
sélectionnons pas tant qu'elles sont dans la table d'origine dans cette instruction from. Donc, même si nous ne les sélectionnons pas pour la visualisation, nous pouvons toujours commander par eux parce qu'ils sont dans la table d'origine. Donc, nous pouvons commander ici, par
exemple, prenons la date de naissance. Donc, nous pouvons commander par nom de naissance et il va par défaut à l'ordre croissant. Pour qu'on puisse faire ça. Eh bien, nous pouvons voir que nous n'avons pas réellement la naissance en colonnes, donc nous ne pouvons pas vraiment vérifier que ce MOOC est toujours en ordre à la date de naissance, même si nous ne l'utilisons pas dans notre déclaration finale de sélection ici. Enfin, une autre chose de syntaxe que nous pouvons utiliser est au lieu de mettre les noms de colonnes ou les alias. Donc, par exemple, ici, nous avons le nom de la colonne et précédemment réutilisé l'alias de colonne. D' abord. Nous aurions tout aussi bien pu utiliser le prénom, vrai nom de colonne ici. Vous pouvez voir que ces deux fonctionneraient, mais nous pouvons également utiliser d'abord comme nous l'avons fait en mettant ceci dans l'ordre décroissant maintenant, puis en utilisant last. Et mettons aussi ceci, ou gardons ceci dans l'ordre croissant. Donc, ici, nous utilisons les alias. On peut utiliser les noms. Et relayons ça à nouveau pour montrer. Mais quelque chose d'autre que nous pouvons également faire est que nous pouvons utiliser le numéro pour la colonne dans laquelle il apparaît dans notre instruction select. Donc, disons que nous voulons d'abord commander par le premier ici, puis le deuxième pi ou LastName. Nous pouvons également utiliser celui, ce qui signifie que nous allons d'abord indexer par la première colonne de notre instruction select. Et puis deux signifie la deuxième colonne de notre déclaration select. Donc c'est encore une fois juste un raccourci que nous pouvons faire au cas où je l'appellerais des noms, prendre trop de temps. Nous pouvons écrire notre code plus propre, plus propre et plus rapide. Donc vous pouvez exécuter ceci et nous pouvons voir que nous allons obtenir les mêmes résultats parce que ça ne change pas. Nous pouvons en avoir un ici qui est référencé, va référencer la première colonne que nous sélectionnons ici. Nous pouvons mettre l'alias ici, qui est l'alias que nous avons assigné à cette colonne. Pour qu'on puisse faire ça et voir. Ou nous pouvons également mettre le nom complet de la colonne. Tous ces éléments sont équivalents. Bien sûr, utiliser l'alias, à mon avis, est un peu plus facile parce que c'est pourquoi nous assignons des alias. B peut bien sûr utiliser le nom complet de la colonne ou la version numérique de celle-ci, en fonction de vos préférences. Les chiffres que je pense sont un bon raccourci, mais parfois ils peuvent être déroutants parce qu'alors vous devez regarder en arrière et vous devez voir ce qui est la première colonne et ce qui est la deuxième colonne. Et au cas où vous sélectionnez quelque chose comme 10 colonnes, vous devez en fait commencer à compter à rebours pour
vous assurer que vous utilisez font référence à la bonne colonne. Donc ça peut être sympa pour le raccourci. Mais bien sûr, vous savez, ils ont tous leurs compromis. Personnellement, je préfère le plus l'alias, mais vraiment c'est à vous de décider de ce qui vous permet de faire les requêtes les plus lisibles. Maintenant, comme nous pouvons également le voir ici par la commande, nous pouvons enchaîner sur un biais de commande supplémentaire. Donc, par exemple, nous pouvons dire, d'accord, nous voulons d'abord commander par la première, la première colonne ici, puis par la deuxième colonne ici, puisque nous avons toujours voulu ses 2s. Ensuite, nous voulons commander, par exemple, par date de naissance, ce qui n'est même pas inclus dans nos colonnes sélectionnées ici. Et ensuite on pourra mettre ça ici. Et disons ici que nous voulons commander descendant. Et puis nous voulons peut-être commander par e-mail. Donc on peut en mettre trois ici si on veut. Ou on peut mettre des courriels comme on veut. Donc nous pouvons voir, et peut-être que nous voulons mettre cela ascendant pour que nous puissions voir, nous pouvons enchaîner différents ordres ensemble, juste en séparant tout par virgule. Et puis l'ordre qui va choisir comme premier va être ce détachement, il va utiliser ceci et sur TI pour les deux, il va utiliser ce détachement pour les trois, il va utiliser ceci et ainsi de suite. Et donc vous pouvez voir pour chaque colonne, nous pouvons également spécifier si nous voulons faire l'ordre décroissant ou croissant.
19. Comparaison directe Filtre conditionnel: Nous venons de voir comment lire les données
de notre base de données. Mais bien entendu, lire la base de données complète
ou la couper après un certain
nombre ou une limite de lignes n'est vraiment pas l'idéal. Idéalement, nous préférons
faire plus avec SQL que simplement lire toutes les
données de notre base de données. La première chose que nous
allons apprendre à faire de plus est le filtrage. Jetons un coup d'œil à
cette piste. Tableau ici. Si nous le
parcourons, nous pouvons voir que nous
avons différentes colonnes ici : l'
identifiant de la piste, le nom de la piste, l'album, l'identifiant du type de média, identifiant du
genre, les compositeurs, l'heure et les millisecondes
de la chanson, la taille en octets de la chanson, ainsi que le prix des Essayons de prendre ce
tableau et essayons de
trouver toutes les chansons
composées par ACDC Pour ce faire, nous allons dire, sélectionner, et nous allons simplement
dire commencer. Dans le tableau des pistes,
appuyez sur Entrée ici. Encore une fois, nous avons les
guillemets. Encore une fois, parce que c'est ainsi
que
le tableau a été créé ,
entouré de guillemets, puis limitons nos
résultats à cinq lignes au cas où, afin pouvoir vérifier avant
de renvoyer le tableau entier. Maintenant, pour filtrer spécifiquement pour quelque chose ou pour
filtrer en général, nous allons avoir une
instruction supplémentaire appelée where. Ici, nous pouvons dire ce que
nous voulons exactement filtrer. Par exemple, nous
voulons actuellement filtrer selon où composer, et nous voulons trouver où le
compositeur est égal à ACDC Comment effectuer cette comparaison ? Eh bien, les
chaînes seront mises entre guillemets
simples
comme nous le faisons ici ou le texte va être mis
entre guillemets simples Accédez à notre base de données ici. Encore une fois, ACDC est écrit majuscule avec une barre
oblique ici Nous allons dire, où le
compositeur est égal à ACDC. Remarquez ici que nous avons
un seul signe égal. Si vous connaissez un autre langage de
programmation, il est habituel d'utiliser des signes doubles égaux et d'autres langages. Mais en SQL,
nous avons ici un seul signe égal. Allons-y et
exécutons cette requête. Nous pouvons voir ici que tous
nos résultats de retour
sont composés par ACDC Ensuite, si nous le voulons, nous pouvons
également désactiver cette limite ici et obtenir la liste complète des lignes ou la
liste complète des enregistrements. Nous pouvons voir que chaque enregistrement ici répond à ce critère
ACDC Maintenant, nous pouvons également faire d'autres
types de comparaisons. Par exemple, une
autre chose que nous pouvons faire est inférieure ou égale à. Bien entendu, cela n'
aura aucun
sens de comparer un nombre inférieur ou égal à avec un nom, car nous procéderons
alors à un tri de texte étrange, qui sera principalement
basé sur des éléments alphabétiques. Cela n'aura pas beaucoup
de sens ici. Utilisons une autre colonne. Utilisez la colonne des millisecondes ici. Supposons que
les millisecondes inférieures ou égales à, et choisissons deux 100 000
millisecondes Nous sélectionnons toutes les lignes ou toutes les colonnes
plutôt à partir de la piste où les enregistrements répondent à
ce critère, où la colonne des millisecondes est
inférieure ou égale Allons-y et limitons à nouveau
notre réponse. Nous allons donc exécuter ça. Maintenant, si nous faisons
défiler l'écran vers la droite,
toutes nos pistes ont une durée inférieure à
200 000 millisecondes, moins Encore une fois, nous pouvons supprimer
l'énoncé des limites. Exécutez cette opération dans son intégralité plutôt que d'
obtenir toutes les valeurs renvoyées, nous pouvons voir qu'elles ont toutes des temps inférieurs à
200 000 millisecondes, moins Nous pouvons également faire une valeur
supérieure ou égale à. Tout ce qui vaut
au moins 200 000. Ceci, et nous obtenons
tout ce dont millisecondes sont supérieures à
200 000
millisecondes, comme nous pouvons le voir ici 200 000
millisecondes Nous pouvons également simplement retirer
le chiffre égal et
simplement dire supérieur à ou nous pouvons également faire un peu moins que Nous pouvons
donc voir que nous pouvons
également effectuer un
filtrage spécifique comme celui-ci. La principale différence, bien entendu, en utilisant un nombre inférieur ou
inférieur ou égal à, est que la valeur égale à
deux inclut également tout ce qui est
égal à 200 000, tandis
que la valeur inférieure à n'inclut que
les instances inférieures à 200 000. Par exemple, ici, nous en
aurions un, neuf, neuf, 999. Ce serait l'instance la
plus élevée que nous puissions inclure en supposant
que tout est intégré ici, car sinon
nous serions égaux à 200 000 ce serait donc égal
et cela ne serait
inclus que dans les cas
inférieurs ou égaux,
ou lorsque nous vérifions l'égalité, ou lorsque nous vérifions que c'est
supérieur ou égal
20. 18FilteringFilteringFilteringGroupComparaisonHB: Donc, nous venons de voir comment nous pouvons faire un filtrage de base en cherchant l'égalité. Sont à la recherche d'une valeur
inférieure ou supérieure ou inférieure à égale ou supérieure ou égale à. Mais qu'en est-il quand nous voulons trouver tous les, par
exemple ici sur la colonne du compositeur, tous les disques où Angus Young, l'
un des compositeurs. Actuellement, nous ne pouvons pas le faire parce que si nous regardons, par exemple, où les compositeurs sont égaux à Angus Young, cela ne va pas nous donner cette valeur parce qu'elle n'est pas exactement égale à elle. Il y a aussi d'autres composants. Et donc actuellement, nous ne pouvons pas utiliser l'égalité pour trouver tous ces enregistrements parce qu'il y a aussi d'autres éléments ici, mais il y a d'autres choses que nous pouvons faire. Alors jetons un coup d'oeil à ça maintenant. Donc, tout d'abord, écrivons à nouveau notre instruction select, sélectionnez toutes les colonnes de la piste. Et limitons nos résultats maintenant. Et encore une fois, nous allons avoir la déclaration où. Maintenant, nous voulons trouver où compositeur, et nous voulons trouver où Angus Young est dans le compositeur. Donc, ce que nous pouvons faire est que nous pouvons utiliser le mot-clé like. Nous allons donc dire où est le compositeur. Et puis on a un message ici, donc on peut dire Angus Young. Mais dans ce cas, on chercherait toujours des correspondances exactes. Mais il y a des personnages que nous pouvons mettre en place qui donnent fondamentalement une certaine place pour agrandir. Donc, si nous utilisons un pourcentage, cela signifie où ce composant est ici. Mais le pourcentage signifie qu'on peut avoir n'importe quoi après ce point. Et le pourcentage devant signifierait aussi que nous avons tout en avant. Donc, nous pouvons avoir plusieurs quantités de personnages devant. Et puis le pourcentage signifie autant de caractères ici. Mais l'important est que quelque part à l'intérieur de nous correspondent exactement Angus espace jeune, comme ça. Si nous enlevons la personne en face, ce serait la rangée devrait commencer avec Angus espace jeune. Et après ça, on peut avoir n'importe quoi. Et si nous avions, par exemple, le pourcentage et la frontière, alors nous devrions essentiellement finir avec Angus espace jeune. Donc, pour être en sécurité, nous pouvons l'utiliser comme ça, ce qui signifie qu'il peut y avoir n'importe quoi devant et n'importe quoi derrière. Mais quelque part dans notre dossier, nous aurions besoin de voir exactement ce texte ici. Alors allons de l'avant et lançons ça. Et nous pouvons voir que toutes les rangées contiennent Angus Young. Et nous allons enlever ou limiter déclaration ici et un réexécuter ceci et faire défiler un résultat, nous pouvons voir maintenant nous avons plus de résultats que tous contiennent Angus Young. Et en fait, dans tous ces cas, Angus Young est la première partie de cette entrée ici. Donc nous pourrions techniquement aussi enlever ce symbole pour cent ici. Et nous aurions toujours le résultat parce qu'il n'y aura jamais rien devant, moins dans ce cas, mais nous ne pouvions pas être sûrs de cela à l'avance. Et si vous vouliez rester en sécurité, nous pouvons toujours laisser ça ici juste au cas où plus tard un enregistrement serait entré où Angus Young n'est pas le prénom à l'intérieur. Mais que se passe-t-il si on enlève ce dernier symbole pour cent ici ? Eh bien, maintenant, nous ne allons pas obtenir de retour parce qu'aucun des enregistrements ne se termine avec Angus Young et nous ne laissons plus l'option d'avoir d'autres personnages par la suite. Donc, nous devons, dans ce cas, nous
assurer que nous avons d'autres caractères après. Juste pour s'assurer qu'il y a cas où à la chaîne Angus Young est contenue à l'intérieur, mais il y a aussi de la place pour d'autres valeurs à inclure dans le même élément ici. Maintenant, il y a aussi un personnage sauvage différent que nous pouvons utiliser. Au lieu d'utiliser le pourcentage, qui perdent de la place pour n'importe quel nombre de caractères, nous pouvons plutôt mettre quelque chose comme un trait de soulignement. Maintenant, le trait de soulignement signifie qu'il peut y avoir n'importe quel caractère ici. Par exemple, remplacons ceci y par un trait de soulignement. Et si nous faisons ça, nous voyons que nous allons toujours obtenir le même résultat parce que nous
cherchons où nous avons de l'espace angus. Et puis ce trait de soulignement ici signifie que n'
importe quel personnage, n'importe quel personnage peut être ici, pas trop, il doit être exactement un. Et c'est sur cette affaire, nous avons le y ici, et ensuite nous avons l'unité d'organisation et g. Si nous enlevons l'espace ici, cela ne fonctionnerait plus. Parce que maintenant nous n'avons plus qu'un seul personnage ici. Mais nous pourrions mettre un symbole pour cent ici, ce qui signifie qu'il y a un nombre quelconque de caractères peut être aussi entre ici. On a juste besoin d'avoir Angus à un moment donné. Et après, nous devons avoir. À ce stade. Vous pouvez donc voir qu'il existe différentes options pour nous. L' un d'eux va être le trait de soulignement, ce qui nous permet de remplacer, juste avoir la possibilité d'avoir un caractère libre. Et puis que nous avons les pourcentages, ce qui nous permet d'avoir autant de caractères que possible. Alors que nous faisons tout cela, la capitalisation est en fait très importante. Si nous changeons ceci en minuscules, ne
fonctionnerait plus parce que nous n'avons plus exactement cette correspondance. Donc, ce que nous pouvons faire,
c'est que nous pouvons utiliser une déclaration différente ici appelée J'aime, ce qui signifie qu'elle est insensible aux cas. Donc, dans ce cas, ça ne se fiche pas s'il y a des lettres majuscules ou minuscules. Et regarde simplement si nous avons cette correspondance de texte et qu'il ne considère pas les cas, il est insensible à la casse. Et donc nous pouvons voir dans ce cas cela fonctionne à nouveau parce que nous avons encore le texte ici. Mais cette fois en utilisant l'IA étaient en fait aller dans la casse insensible. Donc, nous ignorons si tout est en majuscule ou en minuscule. Et on obtient juste la correspondance où le texte est le même. Et vous pouvez voir que nous pouvons capitaliser le G ici, par exemple. Et on aura toujours la même correspondance. Parce que tout ici ou la correspondance que nous faisons d' ici à ici va être insensible à la casse. Maintenant, dans certains cas, nous ne sommes peut-être pas à la recherche de correspondances de texte comme celui-ci, mais nous chercherions un certain nombre de valeurs. Par exemple, jetons un coup d'œil sur nos traces ici. Peut-être que quelque chose que nous voulons est toutes les pistes où l'ID de l'album est soit un, soit l'ID de l'album est quatre. Donc on cherche deux cas. Nous voulons les deux albums 14 ou tous les morceaux qui sont de Al my d1 et album ID pour. Alors, comment pouvons-nous faire ça ? Eh bien, tout d'abord, nous allons changer votre colonne ici encore. On va dire où l'album ID. Et encore une fois, nous devons utiliser les guillemets ici parce que notre Create Table a été défini avec les guillemets pour les colonnes. Habituellement, comme je l'ai dit, les guillemets sont facultatifs. Mais dans ce cas, parce que notre table était de trouver avec les guillemets, nous devons les utiliser. Et maintenant, nous cherchons les cas où se trouve l'identifiant de l'album. Et maintenant les idées d'album que nous recherchons un 14. Nous sommes donc à la recherche de
toutes les colonnes des pistes ici et de tous les enregistrements des pistes où ces enregistrements ont la colonne ID de l'album où la valeur est en un ou quatre. Donc, si nous lançons ceci, nous pouvons voir ici maintenant tous les enregistrements que nous avons renvoyés ont Album ID, soit un ou quatre. Et nous pouvons aussi faire, par exemple, un pour informer. Et comme vous pouvez le voir, nous pouvons étendre cela autant que nous le voulons. Mais il y a aussi des cas où nous voulons peut-être choisir une gamme de nombres. Donc, par exemple, disons que nous voulons trouver tous les albums avec l'album ID un à cinq. Donc, nous pouvons faire, par exemple, 12345 comme ça et exécuter ceci, ce qui nous donnera nos résultats. Maintenant, cela fonctionne, mais ce n'est pas optimal parce que nous devons taper tous ces éléments. Et ça marche toujours parce que nous avons cinq numéros ici. Mais imaginez que nous avions comme 500 ou même plus ou imaginons que nous recherchions une plage de dates. Rien de tout cela ne fonctionnerait vraiment plus. Et il y a une meilleure façon de le faire. Maintenant, l'une de ces façons que nous avons déjà vu à l'avance, qui est l'utilisation supérieure à égale ou inférieure à ou égale. Et puis nous pourrons enchaîner les conditions ensemble, qui est ce que nous apprendrons bientôt. Mais il y a en fait une autre déclaration que nous pouvons faire avec juste appelé entre. Donc nous pouvons dire que nous cherchons les cas où l'ID de l'album est entre 1, pas de parenthèses ici, et cinq. Encore une fois, nous allons sélectionner toutes les colonnes de la table des pistes. Et nous allons filtrer par les disques où les disques ici où une rose a une carte d'identité entre 15. Donc en cours d'exécution, nous pouvons voir toutes nos valeurs ici sont comprises entre 15, inclusivement aux deux extrémités. Et maintenant, comme vous l'avez peut-être déjà deviné, génial à cause de la suggestion que nous avons reçu de notre éditeur SQL ici. Nous pouvons aussi ne pas faire entre, ce qui signifie que nous allons seulement regarder les enregistrements où se trouvent les valeurs. Les ID de l'album ne sont pas compris entre 15. Donc, si nous exécutons ceci, nous voyons que tout ici a des valeurs non comprises entre 15. Et cette déclaration NOT fonctionne également pour les autres choses que nous avons examinées. Par exemple, pas comme. Et là, nous pouvons faire AC, DC. Donc n'importe quel endroit où le compositeur n'est pas comme ce texte ici, AC ,
DC, qui va nous donner tous les disques où le compositeur n'est pas cette chaîne ac-dc.
21. 19RejoigneauxHB: Donc maintenant, nous connaissons déjà une bonne quantité de filtrage. Mais parfois même le filtrage que nous connaissons actuellement ne suffit pas. Parfois, nous devons faire plus. Parfois, nous avons besoin de joindre des conditions de filtrage spécifiques ensemble pour obtenir vraiment les résultats que nous voulons. Alors, comment pouvons-nous faire ça ? Eh bien, nous allons y travailler avec un exemple. Essayons de trouver tous les disques ici où notre compositeur est égal à AC, DC et la longueur de la chanson est supérieure ou égale à 250 000 millisecondes. Donc, nous allons dire sélectionner toutes les colonnes de la table de piste. Nous allons filtrer les lignes où le compositeur. Et maintenant, nous pouvons soit dire égal à, soit nous pouvons utiliser le similaire ici. Mais nous allons utiliser un était égal à parce que nous voulons l'égalité exacte. Donc, nous allons dire où les compositeurs sont égaux à AC, DC et la colonne millisecondes est au moins supérieur ou égal à 250 000 millisecondes. Donc, si nous exécutons ceci, nous pouvons voir maintenant nos résultats sont tous
les chansons d'ac-dc sont tous les chromosomes de cette base de données, où ici les millisecondes sont supérieures ou égales à 250 000. Nous pouvons bien sûr, aussi changer cela et chercher moins ou égal à 0, qui dans ce cas je suis ne nous donne qu'un seul record. Nous pouvons voir que nous pouvons utiliser la déclaration and ici pour faire un filtrage. Mais rendons cela encore plus complexe. Disons que nous voulons trouver tous les cas où les pistes millisecondes sont supérieures à 250 mille. Mais nous voulons seulement les chansons où les octets sont inférieurs à. On est arrivés ici, trois et trois autres. Donc nous avons 10 millions, c'est un peu l'ordre de grandeur avec lequel nous travaillons. Donc, nous voulons trouver toutes les chansons où les octets sont inférieurs à 10 millions. Donc, nous pouvons ajouter si nous voulons. Une autre condition ici, disons et nous sommes octets est inférieure ou égale à dix millions. Et quelqu'un peut exécuter ça. Et alors nous pouvons voir que nous obtenons ces pistes spécifiques retournées. Alternativement, au lieu de chaîner avec et nous pouvons également utiliser des instructions ou. Donc, par exemple, nous allons chercher toutes les chansons qui sont
faites ou nous allons commencer par toutes les chansons qui sont faites par AC, DC ou qui ont au moins 1 050 000 000 millisecondes. Donc, l'instruction OR ici signifie que nous recherchons pour correspondre à l'une ou l'autre de ces conditions. Alors allons de l'avant et lançons ça. Et nous pouvons voir ici, soit nous avons ac-dc, auquel
cas, comme nous pouvons le voir ici, nous pouvons trouver la ligne. On y va. La colonne millisecondes est inférieure à 250 000. Ou dans les cas où les compositeurs non ac-dc, tous les millisecondes est au moins égal ou supérieur à 250 mille. Donc, nous pouvons voir ici nous avons une déclaration ou. Maintenant, ce que nous pouvons aussi faire c'est cool, c'est que vous pouvez continuer à chaîner les conditions en utilisant des parenthèses. Donc, par exemple, nous allons chercher toutes les chansons où le compositeur est ac-dc ou la piste est plus longue que 250 mille millisecondes. Bud Il est octets est également inférieur ou égal à 10 millions. Donc, nous voulons soit AC, DC ou au moins 250 secondes et moins de 10 millions d'octets. Donc l'une ou l'autre de ces deux conditions, mais la seconde nous devons le faire. Donc ce que nous pouvons faire, c'est nous pouvons utiliser des parenthèses ici. Et puis nous pouvons dire, et octets est inférieur ou égal à 10 millions. Et donc, ce qui va se passer, c'est que cette déclaration va être évaluée comme une seule. Et ça va être comparé à celui-ci. Donc, soit nous avons celui-ci, soit nous avons le résultat ici où ces deux conditions doivent être remplies. Vous pouvez donc voir qu'il y a beaucoup de choses que vous pouvez faire avec un filtrage en utilisant le et dans l'ordre, ainsi que l'utilisation de parenthèses pour décider quelles conditions doivent être réunies. Maintenant, bien sûr actuellement, nous utilisons juste des choses comme égal ou supérieur à égal ou inférieur à égal à. Mais cela fonctionnera aussi bien si nous mettons ici, par
exemple, le similaire, ou si nous mettons là dans une gamme, tout cela fonctionnera exactement de la même manière. Nous pouvons utiliser les autres mots-clés que nous avons également appris dans où les déclarations ici, et aussi continuer à changer les conditions en utilisant les rames, utilisant les and et en mettant des parenthèses autour des conditions que nous voulons regrouper comme une parenthèse ou plutôt que nous voulons regrouper en une seule unité. Et nous pouvons également continuer à enchaîner les parenthèses. Donc, par exemple, ici, nous pouvons alors mettre une autre parenthèse et faire plus de choses, par
exemple, et les octets sont inférieurs à 10 millions. Ou je ne sais pas, pensons à quelque chose ou un compositeur est comme. Et puis, en fait, passons ceci à une nouvelle ligne pour rendre ce plus propre et déplacer ceci vers une nouvelle ligne. Et le compositeur est comme Angus Young. Notez que nous utilisons la lumière ici, pas celle que j'aime, donc nous devons utiliser le boîtier correct. Donc, dans ce cas, et assurons que nous fermons les parenthèses 2. Nous cherchons soit où le compositeur est comme ac-dc, soit où les millisecondes sont supérieures ou égales à 250 000 et où nos piqûres sont inférieures à 10 millions. Ou les compositeurs comme Angus Young. Alors exécutons ceci pour voir les résultats. Et alors ce que nous faisons ici, revenons en arrière. Soit nous vérifions la, tout d'
abord, nous avons la condition ici. Donc tout ce qui est AC-DC va être là. Mais maintenant, ce que nous avons ici, c'est nous recherchons moins ou moins de 10 millions d'octets ou que le compositeur doit avoir Angus Young dedans. Et puis si l'un de ces deux est vrai, nous devons aussi constater que les millisecondes sont supérieures ou égales à 250 mille. Donc, par exemple, nous pouvons voir dans cet enregistrement ici, nous avons les octets étant supérieurs à 10 millions. Mais notre compositeur est comme Angus Young. Donc, cette partie de la condition est remplie, qui rend ceci ou déclaration vrai. Celle-là. Donc celui-ci est vrai. Maintenant, nous avons besoin de celui-ci et celui-ci pour être vrai. qui signifie que nos millisecondes doivent être supérieures ou égales à 250 000, qui est ce que nous avons ici. Donc nous l'avons fait, celui-ci est vrai, et celui-ci est vrai. Maintenant, nous devons dire soit porter un compositeur comme AC, DC, qui est faux, soit où tout ce segment ici était vrai, ce
qui n'est pas le cas. Donc, nous pouvons voir que nous pouvons faire une logique assez compliquée en utilisant le filtre
ici en enchaînant ensemble sont différentes opérations comme, comme V est égal à IR que j'aime entre les deux, ainsi que l'utilisation des ands et des ors et faire entre parenthèses pour regrouper les choses que nous voulons avoir regroupées.
22. 20NegatingConditionalsHB: Bon, maintenant on a vu un tas de filtrage là où les conditions sont vraies. Mais dans certains cas, nous voulons que les conditions ne soient pas vraies. Maintenant, nous avons déjà vu ça, mais regardons un peu plus en détail. Donc, en revenant à notre table de piste ici,
commençons par chercher tous les cas où Composer n'est pas égal à AC, DC. Donc, ce que nous pouvons faire ici, vous pouvez sélectionner, il suffit de sélectionner toutes nos colonnes de la table de piste et conscient du compositeur. Et maintenant d'avoir pas égaux, et nous pouvons avoir un point d'exclamation égal. Et puis nous allons mettre le texte ac-dc. Donc, cela va nous donner tous les disques où le compositeur n'est pas égal à AC, DC, comme on peut le voir ici, aucun de ces disques contenant CDC. Et ce que nous pourrions faire ici parce que nous avons du texte ici. Donc on pourrait dire pas comme ACC, ce qui signifie tous les cas où ce n'est pas comme ce texte ici, qui va nous donner le même résultat dans ce cas. Maintenant, nous pouvons aussi faire d'autres choses. Par exemple, pas entre, ce que nous avons vu. Donc on peut dire pas entre les deux. Et nous voulons dire parce que dans ce cas entre n'a pas beaucoup de sens pour la colonne du compositeur puisque c'est tout du texte. Utilisons donc l'ID de l'album. Nous voulons donc trouver tous les disques où l'ID de l'album n'est pas compris entre 46. Donc ça va nous donner tous les disques ici sont l'identification de l'album n'est pas entre 46, donc pas quatre, pas cinq, pas six, et tout le reste que nous allons obtenir. Ou on peut aussi rien faire ici. Et puis mettre nos parenthèses, ce qui signifie que notre ID d'album n'est pas en 46, ce qui signifie qu'il n'est pas égal à 46. Donc, si nous courons ce risque maintenant d'obtenir l'ID d'album cinq parce que nous ne les utilisons pas entre, mais maintenant nous faisons spécifiquement correspondre les instances ici. Donc, nous pouvons voir que nous pouvons utiliser les pas égaux deux, par
exemple, comme ceci, pour faire la négation pour le cas d'égalité. Et nous pouvons faire la déclaration NOT pour certains des autres plus complexes où les méthodes que nous avons. Maintenant, vous pouvez, vous vous demandez peut-être, eh bien, qu'en est-il de l'opposé de plus que égal à ? Comment pouvons-nous annuler ça ? Eh bien, nous avons déjà une déclaration pour ce qui est le moins de. Donc, nous pouvons dire que tout ce qui n'est pas supérieur ou égal sera inférieur à. Et tout ce qui n'est pas inférieur à, il peut être supérieur ou égal à. Et puis on peut obtenir la même chose, vice versa. Maintenant, une autre chose que je veux ajouter ici, si nous revenons juste à certains de nos résultats précédents pour l'intervalle, est que dans certains cas, nous pouvons effectivement vouloir commander nos résultats aussi. Alors regardons les résultats de cela. Vous avez notre ID d'album n'est pas entre 46. Ai-je besoin de revenir plus loin ? Encore troublé ? D'accord. Bizarre. Ça semble aller. Alors nous allons tout commander par notre identifiant d'album ici. Donc, l'instruction order BY que nous avons déjà appris, mais il doit en fait y avoir un ordre spécifique pour les emplacements où nous plaçons ces instructions SQL. Donc SARSA sélectionner et nous avons le de. Dans ce cas, nous allons avoir l'endroit et l'ordre va venir après. Ainsi, par exemple, nous voulons commander par ID d'album dans l'ordre décroissant, ce qui signifie le plus haut en premier. Donc, si nous exécutons ceci, vous pouvez voir que nous commençons avec l'ID d'album le plus élevé et que nous allons vers le plus bas. Maintenant, il est important que cette commande BY vienne après la déclaration where. Parce que si nous le mettons avant l'instruction where, alors nous allons avoir une erreur parce que, eh bien, allons tout faire parce que ça n'appartient pas là. Ce n'est pas l'ordre correct de la syntaxe SQL. Alors Dasa vient après. Maintenant aussi, la même chose avec l'instruction limit. L' instruction limit doit arriver à la fin. Donc, tout ce que nous avons appris pour cet ordre BY instructions est toujours vrai parce que toujours faire des commandes supplémentaires en faisant des virgules ici. Mais il est important que l'ordre dans lequel nous faisons ces commandes soit dans cet ordre spécifique. Dans ce cas, il va commencer par select et à partir de l'instruction where, puis l'ordre BY et ensuite nous avons la limite parce que si c'est dans un autre ordre et cela ne fonctionnera pas.
23. 21FilterFilterNullValuesHB: Maintenant, il y a un cas particulier de filtrage que nous n'avons pas encore examiné. Alors jetons un coup d'oeil à notre table de compositeurs ici encore. Certaines de ces instances peuvent avoir des valeurs manquantes, qui sont représentées ici comme des valeurs nulles. Donc, actuellement, il n'y a aucun moyen réel que nous sachions comment vérifier pour cela encore. Alors jetons un coup d'oeil à eux. Donc, nous allons tout d'abord, sélectionnez toutes nos colonnes de notre table de camion, filtrant pour les disques où le compositeur. Et maintenant, nous voulons tout dire. Nous voulons trouver tous les cas où le compositeur est nul ici. Donc, pour ce faire, nous devons réellement écrire est nul. Et puis un point-virgule juste pour finir ou une requête SQL ici et puis frapper une course. Et donc maintenant nous obtenons tous les cas où la valeur ici dans la colonne du compositeur est nulle. Maintenant, l'important est que nous ne faisons pas ça égal ici, parce que ce n'est pas correct. Nous voulons nous assurer que nous le faisons est nul. C' est la bonne déclaration à utiliser. Maintenant, pour la négation, ça va être assez simple et vous avez peut-être déjà vu cela dans la suggestion de code. Tout ce que vous avez à faire est d'écrire N'EST PAS null. Et ça va nous donner tous les cas où le compositeur n'est pas connu. Et donc ça va marcher comme n'importe quel autre conditionnement que nous avons eu ici. Encore une fois, dans ce cas, nous avons juste un cas spécial à utiliser quand il n'y a pas de valeurs contenues à l'intérieur. Mais tout ce que nous avons appris sur la déclaration où est toujours vrai.
24. 22CréerNewColnsAndArithmeticsHB: Donc, dans cette leçon, regardons comment nous pouvons faire certaines opérations sur nos colonnes. Ouvrons à nouveau notre table de piste ici. Et la première chose que nous devrions faire est d'essayer de
convertir cette colonne d'octets à la place en kilo-octets. Pour ce faire, nous allons tout diviser ici par 1024. Alors, comment pouvons-nous faire ça ? En revenant à notre console, nous allons écrire select, et ensuite nous laisserons Star ici comme modèle pour l'instant, mais nous reviendrons et changerons ça dans une seconde. Nous sélectionnons l'étoile de la piste. Et limitons aussi nos résultats à cinq pour l'instant, juste au cas où une bonne pratique ou nos tables maintenant tubing ici. Mais juste au cas où nous avions des millions de lignes ou quelque chose, ce serait bon de tester et de ne renvoyer qu'un petit segment de ces lignes. Bon, alors choisissons pour l'instant et juste la colonne d'octets. Et nous allons le convertir aussi deux kilo-octets. Donc la première colonne que nous voulons sortir va être des morsures. Et la deuxième colonne que nous voulons sortir est à nouveau la colonne octets. Mais ici, nous voulons le
diviser, diviser par 1024 pour le faire en kilo-octets. Alors faites alors, nous pouvons simplement utiliser la barre oblique ici pour la division et mettre le numéro 1024. Et cela va diviser les valeurs de cette colonne ici par 1024. Et puis nous pouvons utiliser un alias pour, pour le rendre plus, pour lui donner un meilleur nom. Donc, nous pouvons enregistrer ceci ici sous forme de kilo-octets par exemple. Alors allons de l'avant et lançons ça. Et nous pouvons voir ici, ici nous avons les octets et ici nous avons la même quantité, mais en kilo-octets à la place. Bien sûr, l'opération de division n'est pas la seule chose que nous pouvons faire. Nous pourrions aussi faire d'autres choses telles que, et peut-être, créons de nouvelles colonnes pour cela. Alors multiplions nos morsures. Peut le multiplier par deux, par exemple. Et ici, nous pouvons enregistrer cela comme octets multipliés juste pour être en mesure de les différencier. On peut faire des soustractions. Par exemple, nous pouvons prendre nos tuyaux et en soustraire quelque chose. Et puis ici, nous pouvons appeler ce sous-octets pour les octets soustraits. Et puis faisons aussi juste l'autre, qui va être un ajout. Et ici, ce sera nos octets ajoutés. Donc je vais juste mettre quelques espaces ici pour rendre tout le formatage agréable. Donc, si nous exécutons ceci, vous pouvez voir ici il y a beaucoup d'opérations différentes est opérations arithmétiques
simples que nous pouvons faire sur nos colonnes. Donc, vous pouvez voir ici nous avons en quelque sorte toutes les opérations par défaut disponibles pour nous. Nous pouvons également faire d'autres choses cool plutôt que simplement utiliser des valeurs numériques fixes. Nous pouvons également utiliser d'autres colonnes. Par exemple, essayons de trouver une nouvelle colonne. C' est le nombre d'octets par milliseconde de longueur de chanson. Nous allons donc diviser les valeurs dans la colonne octets par celles de la colonne millisecondes. Et puis nous obtenons le nombre d'octets par milliseconde et la piste. Donc, pour ce faire, nous allons prendre notre colonne morsures et nous allons la diviser par la colonne millisecondes. On va lui donner un alias appelé octets par million. Donc octets par milliseconde. Et encore une fois, nous pouvons exécuter ça. Et nous pouvons voir ici maintenant nous avons différentes valeurs du nombre d' octets utilisés pour stocker la chanson par milliseconde de longueur de la chanson. Et nous ne pouvons pas faire aussi d'autres choses cool ici. Par exemple, nous pouvons commander maintenant par nos bouchées par milliseconde si vous le souhaitez. Donc peut-être que la première chose que nous devrions faire est juste d'enlever cette déclaration de limite ici. Et nous allons courir encore une fois pour obtenir les résultats complets. Et sortons aussi le nom de la piste afin que nous puissions voir ce qu'est cette piste. Et donc nous allons supprimer ceci maintenant et juste prendre le nom de la piste. Et nous n'avons pas besoin de donner un nom supplémentaire. Nous n'avons pas besoin de fournir des ajouts supplémentaires ou quoi que ce soit ici. Parce qu'ils ne le sont pas, ils ne signifient pas grand-chose ici ces multiplications sont des soustractions, mais comme vous pouvez le voir, nous ne pouvons pas les faire. Bon, donc nous avons nos bouchées calmes. Si nous exécutons ça, nous avons nos kilo-octets, nous avons le nom de la chanson et aussi les octets par milliseconde. Alors allons de l'avant et ordonnons nos résultats par les octets par milliseconde dans l'ordre croissant. On va commander BY maintenant. Nous pouvons avoir différentes façons. Ainsi, par exemple, nous pouvons commander par quatre être le moyen le plus rapide. Et c'est un peu facile à voir ici parce que maintenant il est toujours facile de compter le nombre de colonnes que nous avons. Vous pouvez également commander par octets par millilitre si nous le voulons. Donc, nous pouvons voir ici nous obtenons les mêmes résultats ou nous pouvons réellement répéter l'opération et l'ordre par octets par millisecondes comme ceci. C' est de loin le moins idéal. Probablement. Il est préférable d'utiliser l'alias de colonne réel que vous avez assigné ici. Mais juste pour vous montrer, nous pouvons le faire et si nous pouvons aussi le faire dans l'ordre décroissant, bien sûr. Alors on y va. Maintenant, nous pouvons voir qu'il existe différentes façons de faire des opérations arithmétiques simples, la
fois avec des valeurs naturelles et aussi l'utiliser entre différentes colonnes. Maintenant, faisons autre chose. Parce que aussi ici, nous pouvons rendre cela plus complexe en ajoutant des choses comme des parenthèses. Nous avons donc vu cela lorsque nous faisons
des conditions de jointure et où nous avions la possibilité d'utiliser et or ainsi que des parenthèses. On peut faire la même chose ici. Alors prenons quelque chose et prenons notre carte d'identité de camion. Et ajoutons à cela l'identifiant de l'album multiplié par l'ID du type de média. Donc ici, par exemple, nous allons prendre notre identifiant de camion. Et puis nous allons ajouter. Et puis nous pouvons prendre notre ID d'album plus l'ID de type de média, fois l'ID de type de média. Ce n'est pas le cas, ça ne veut pas vraiment dire grand-chose, mais juste pour vous montrer qu'on peut faire tout ça. Donc, tout d'abord, nous avons une simple addition et multiplication. Et cela, nous pouvons simplement appeler en ce moment comme colonne personnalisée. Et on va aller de l'avant et faire ça. Nous pouvons voir ici que nous obtenons les résultats de quoi que ce soit. Mais si nous utilisons des parenthèses, nous pouvons effectivement faire r plus opération d'abord, et ensuite nous pouvons faire notre opération de multiplication. Donc, tout comme nous l'avons fait pour nos conditions où nous pouvons utiliser des parenthèses, nous pouvons aussi faire exactement la même chose ici pour utiliser des parenthèses. Et puis nous pouvons voir évidemment maintenant que cette chose va être évaluée comme une seule unité. Et puis le résultat de ceci va être multiplié. Ainsi, comme vous pouvez le voir, nous pouvons également faire des modifications à nos colonnes ici. Faire des divisions de colonnes sont en quelque sorte de diviser une colonne par l'autre. Nous pouvons également multiplier les colonnes les unes par les autres. Nous pouvons ajouter des colonnes les unes aux autres, et nous pouvons également utiliser des parenthèses pour dicter l'ordre des opérations que nous voulons utiliser.
25. 23DatatypeConverstionsHB: Maintenant, auparavant, nous avons vu que nous pouvons faire, par
exemple, des divisions ici. Et nous l'avons fait en divisant notre colonne de morsures par un 1024 pour la convertir en kilo-octets comme nous le voyons ici. Mais vous avez probablement réalisé, ou vous vous êtes probablement demandé, que diviser toutes nos morsures, toujours acheter un 1024. Il est très peu probable que nous ayons toujours des valeurs entières parfaites ici. Et tu as absolument raison. Ce n'est pas très probable. Et beaucoup d'entre eux sont en fait des nombres à virgule flottante sont, beaucoup d'entre eux sont des nombres réels ou des nombres décimaux. Mais ils ont été convertis en entiers parce que nous avons un entier ici et un entier ici. Donc, nous faisons des divisions entières. Donc, dans cette leçon, nous allons examiner comment nous pouvons changer nos types de données pour qu'ils soient des valeurs différentes. Maintenant, dans ce cas, ça va être assez facile parce qu'une chose que nous pouvons faire est que nous pouvons changer notre 1024 pour 1024. Et cela va le changer d'un entier à un nombre décimal. Donc, si nous exécutons ceci, nous pouvons voir ici maintenant nous avons réellement décimal est inclus dans nos divisions. Et pour que nous puissions voir les résultats ici. Évidemment, il y a des nombres décimaux, alors qu'au préalable nous les avions juste arrondis à l'entier le plus proche. Mais il y a aussi différentes façons de le faire. Et puisque nous n'allons pas toujours utiliser des nombres codés en dur comme celui-ci. Mais souvent, nous voulons peut-être faire référence à des colonnes spécifiques ou nous voulons changer les types de colonnes. Ce n'est pas toujours possible. Donc, par exemple, nous ne pouvons pas faire la même chose à la colonne octets. On ne peut pas mettre un 0 ici. Et vous pouvez voir que si nous exécutons ceci, nous allons avoir une erreur parce que encore une fois, cela ne fonctionnera pas. Il y a donc d'autres façons de faire la même chose ici. Cela va être appelé typecasting. Donc, ce que nous pouvons faire est, et essayons ceci sur la colonne octets. D' abord. Nous pouvons lancer, nous pouvons jeter nos morsures. Et puis nous avons mis ici le mot-clé As. Et puis nous allons mettre ici le type de données. Et maintenant, nous pouvons lancer notre colonne et changer le type de données. Par exemple, nous pouvons le changer actuellement c'est l'entier par défaut, que nous pouvons voir aussi si nous ouvrons cela et nous regardons les octets, nous pouvons voir que c'est un entier ici. Donc, nous pouvons lancer, par exemple, pour être un vrai type de données. Donc, si nous exécutons ceci et dans ce cas, nos résultats ne vont pas changer simplement à cause de la façon dont ils sont affichés. Mais nos valeurs ici sont en fait maintenant un vrai type. Donc, appliquons la même chose ci-dessous et voyons effectivement quelques résultats. Alors jetons notre numéro 124 à la place pour être en nombre réel. Donc, nous allons lancer 1024 comme un vrai nombre. Donc ce n'est pas un vrai nombre ici. Donc si nous faisons ça, vous pouvez voir ici maintenant nous avons encore cette division à virgule flottante. Encore une fois maintenant avoir des décimales. Et les types de données que nous pouvons mettre ici sont
les types de données que nous avons appris dans la leçon d'introduction. Ainsi, vous pouvez lancer vers n'importe quel type de données qui sont disponibles pour nous. Donc on peut faire le casting comme ça. Et comme vous pouvez le voir, nous pouvons, nous pouvons lancer sur des entiers individuels. Nous pouvons également lancer sur des colonnes complètes. Par exemple, comme nous l'avons vu ci-dessus. Nous pouvons lancer nos morsures aussi pour être un type de données réel. Donc si nous faisons ça et que nous pouvons voir ce sont les résultats que nous allons obtenir. Maintenant. Tous ceux que nous faisons ici sont en train de changer le type de données. Maintenant, une façon de le faire, est
encore une fois d'utiliser l'instruction CAS ici. Mais une autre façon de le faire est, et je vais le montrer d'abord sur notre 1024, mais cela fonctionne partout ailleurs aussi. Nous pouvons également lancer cela en utilisant cette syntaxe. Donc on va mettre deux deux-points. Et puis ici, nous pouvons mettre le type de données vers lequel nous voulons le lancer. Donc ça marche comme ça. Vous pouvez voir ici, ou avoir ceci, ces
deux sont équivalents. Eh bien, trillion, ces deux sont équivalents. Il y a donc différentes façons que nous pouvons lancer. L' un d'eux est ce que nous venons de voir, qui est la distribution comme l'autre utilise ces deux points, qui nous permet de lancer la valeur devant ce nouveau type de données. Donc, nous pouvons aussi le faire, par
exemple, à nos morsures ici. Mais convertissons ceci en texte. Parce que maintenant nous allons avoir un problème, puisque nous essayons de diviser le texte par valeur numérique et que cette opération n'est pas définie. Donc, nous pouvons voir ici, nous pouvons jeter les deux valeurs individuelles que nous mettons ici,
ce qui, bien sûr, ne sera pas aussi utile. Mais nous pouvons également lancer des valeurs complètes ou nos colonnes complètes, mais nous pouvons également lancer nos colonnes complètes deux types de données différents. Et cela peut être vraiment agréable pour différentes opérations. Ou aussi si vous êtes type de données et les colonnes de la mauvaise valeur. Par exemple, si vous stockez une valeur numérique à la place comme une chaîne, alors si vous essayez de faire des divisions, cela ne fonctionnera pas même si vous l'avez fait. Par exemple, regardons, eh bien, prenons ceci et convertissez-le en texte. Et puis si nous convertissons aussi cela en texte, alors cela va être un problème pour nous parce que nous ne pouvons pas diviser texte par texte. Donc, dans ces cas, ce que nous pouvons faire, c'est que nous pouvons lancer des valeurs de nos textes, deux entiers, par exemple. On peut faire la même chose ici. Nous voulons avoir ceci à l'extérieur et les octets client ici, deux entiers. Et donc, dans certains cas, lorsque les types de données sont foirés dans notre base de données, par exemple, ou aussi lorsque nous voulons effectuer des conversions de types de données pour différentes raisons, nous pouvons utiliser le casting avec les deux syntaxes. L' un d'eux est ce double deux-points, et l'un d'eux est cette fonte en tant que syntaxe de type de données. De cette façon, nous avons également plus de flexibilité pour
gérer les types de données et pour passer à différents types de données.
26. 24LogicStatementsHB: Maintenant, dans certains cas, nous voulons peut-être aussi inclure des instructions logiques dans les requêtes SQL. Voyons donc un exemple simple de la façon dont nous pouvons le faire. Reprenons notre table de piste ici encore. Et passons à nouveau par les compositeurs. Et maintenant, nous allons faire une nouvelle colonne qui
dit essentiellement oui ou non si le compositeur est AC, DC. Alors jetons un coup d'oeil à eux. Allons de l'avant et tout, il suffit de sélectionner tout dans notre colonne camion et de limiter nos résultats à cinq. Un peu comme d'avoir ce code squelette ici parce qu'après cela, vous pouvez revenir et le changer. Donc juste pour avoir le squelette ici. Donc la première chose que nous allons faire est de choisir le compositeur, quelle colonne, juste pour que nous ayons la vraie valeur à comparer. Et maintenant, nous voulons faire une nouvelle colonne. Et nous pouvons appeler que, par exemple, est AC, DC, ce qui va être oui. Quand notre compositeur ici est AC, DC et ne sera pas autrement. Alors, comment pouvons-nous faire ça ? Nous pouvons utiliser l'instruction de cas qui fait partie de notre, qui fait partie de SQL. Donc, nous pouvons dire cas quand le compositeur est égal à AC, DC, alors oui, non. Et puis nous allons sauver ça en tant qu'ac-dc. Jetons donc un coup d'oeil à cette déclaration complète ici. Le mot-clé case indique que nous allons commencer une déclaration de cas ici. Et puis nous avons le seul mot-clé qui dit quand cette condition, alors nous faisons ce qui suit. Sinon, on a ça. Il y a encore une chose qui nous manque à la fin de chaque déclaration de cas. Une fois toutes nos affaires terminées, il faut mettre fin ici. Donc, cela commence avec le cas où le compositeur est égal à AC, DC. Et maintenant, nous avons déjà vu cette comparaison quand nous regardons le filtrage, particulier les déclarations where. Donc, nous faisons cas lorsque les compositeurs ac-dc, alors la valeur va être OUI. Sinon, la valeur sera non. Fin pour indiquer que c'est la fin de notre déclaration de cas. Alors faisons ça. Et nous pouvons voir ici que nous avons deux colonnes. Donc, le premier est nos compositeurs ici. Et actuellement, nous limitons nos résultats. Alors allons de l'avant et enlevons cette déclaration de limite et passons par quelques résultats supplémentaires afin que vous puissiez voir tout où il n'est pas égal à AC, DC que nous avons connu. Et quand il est égal à AC, DC, nous avons, oui, comme nous pouvons le voir ici. D' accord, cool. Nous pouvons aussi bien sûr, diviser cela sur plusieurs lignes pour le rendre plus facile à lire afin que nous ne sachions pas, passer sur autant de lignes. Donc, nous pouvons faire quelque chose comme ça, par exemple. Et ça va encore nous donner les mêmes résultats. Maintenant, nous pouvons aussi faire plus de choses. Par exemple, plutôt que d'avoir juste 11 déclaration, nous pouvons également en avoir plusieurs. Donc, disons que nous voulons avoir une vérification séparée et revérifier quand le compositeur est comme. Et maintenant, nous allons utiliser la déclaration de lumière que nous avons également vu auparavant. Et ici, nous allons chercher Angus Young, n'importe où là-dedans. Alors on va dire peut-être autre, non. Alors nous allons recommencer ça. Et nous pouvons voir ici dans le cas où Angus Young est à l'intérieur, peut-être dans le cas où il n'y a ni Angus Young ni AC DC à l'intérieur. Nous avons NON. Et sinon quand AC, DC est à l'intérieur, alors nous avons oui. Maintenant, la chose importante à être également au courant ici est bien que nous ayons un ordre spécifique. Donc, d'abord, nous cherchons cette déclaration, puis nous cherchons cette déclaration. Et ceci va être notre déclaration de repli. Donc, selon l'ordre dans lequel vous les mettez, vos résultats peuvent ou non changer en fonction des comparaisons que vous utilisez. Maintenant, dans ce cas, nous utilisons l'énoncé égal et la déclaration de lumière. Mais bien sûr, nous avons également vu d'autres déclarations que nous pouvons utiliser pour la comparaison lorsque nous passons par le filtrage spécifiquement. Peut-être pour nettoyer ça un peu plus. Je vais mettre les déclarations quand et Venn sur les mêmes lignes. Ou je peux aussi diviser chacune de ces lignes séparées, juste quelque chose qui le rend intuitif à lire, mais aussi quelque chose qui empêche nos requêtes SQL de s'enfuir trop étrangères à l'horizontale, ce qui également pas le rend très lisible. Nous pouvons donc voir que nous avons beaucoup d'options différentes en utilisant les déclarations de cas. Et nous pouvons aussi faire d'autres choses. Par exemple, nous n'avons pas besoin de mettre une valeur de texte ici. Nous pouvons avoir ici, par exemple, le 1. Ici, on peut avoir 0,5. Et sinon nous pouvons mettre 0. Et nous pouvons exécuter ça et nous pouvons voir les résultats ici. Donc, nous pouvons voir que nous ne sommes pas seulement limités à mettre seulement du texte. Cependant, les types de données que nous choisissons doivent être compatibles les uns avec les autres. Par exemple, quelque chose qui ne va pas fonctionner est si nous mettons ici, peut-être parce que maintenant il ne sait pas quel type de données choisir. Donc, vous pouvez voir ici, il essaie d'utiliser un entier, mais quand il rencontre le texte et il devient juste confus. Assurez-vous donc simplement que les types que vous utilisez sont compatibles les uns avec les autres. Comme vous pouvez le voir ici, tout cela va être réel comme des nombres. Donc tout ça devrait bien fonctionner. Ce qu'on va utiliser des textos à l'avance. Et bien sûr, nous pouvons enchaîner, continuer à enchaîner ces déclarations conditionnelles si nous le voulons, en fonction d'autres choses que nous recherchons. Et nous pouvons à nouveau utiliser ces opérateurs de comparaison, que nous avons également vu auparavant. Donc, ce qui est cool dans les instructions de cas est maintenant que nous avons un moyen et une logique dans nos requêtes SQL. Et encore une fois, ils vont créer de nouvelles colonnes pour nous. Et ces nouvelles colonnes contiennent des valeurs qui sont spécifiquement constituées d'instructions de cas que nous avons définies ici. Encore une fois, la syntaxe importante est juste que nous avons un cas pour indiquer le redémarrage de l'instruction de cas. Puis, euh, quand je dis que nous commençons la comparaison ou conditionnel ici, alors nous avons le conditionnel réel que nous recherchons. Si ce conditionnel est vrai, alors nous avons ce mot-clé. Nous allons prendre cette valeur. Ce conditionnel n'est pas vrai. Nous allons passer à la suivante, à la prochaine déclaration. S' il y a une instruction X1, regardez cette condition. Si cette condition est vraie, alors nous allons prendre cette valeur et nous allons
continuer à travers chaque condition que nous avons. Si nous en avons encore plus quand. Et puis des déclarations ici. Et puis nous continuerons à passer par tout ça. Et si tout cela échoue, alors nous allons revenir à cette déclaration else, qui est quand tout ce qui précède échoue, alors nous allons prendre cette valeur. Et puis nous allons sauver ou colonne le donner. Et cet alias, comme on peut le voir ici.
27. 25ManipulationStringsHB: Donc, dans cette leçon, jetons un coup d'oeil à la façon dont nous pouvons faire un peu de rognage de texte. Jetons un coup d'oeil à certaines de nos colonnes. Et encore une fois, en quelque sorte de retour par défaut à la colonne du compositeur, que nous avons beaucoup utilisé dans ces tables de piste ici. Essayons de sortir l'a au début de chaque enregistrement ici. Donc pour ce faire, nous allons choisir juste écrire notre squelette, tout de la piste. Et limitons,
limitons nos résultats à cinq pour l'instant. Encore une fois, ce que nous voulons, c'est que nous voulons que le compositeur se compare, pour s'assurer que tout fonctionne correctement. Et maintenant ce que nous voulons faire, c'est nous voulons prendre la colonne du compositeur, mais nous voulons supprimer s'il y en a un, le a au début. Alors, comment pouvons-nous faire ça ? Eh bien, il y a un SQL très cool, il y a une fonctionnalité SQL très cool que nous pouvons utiliser appelée L Trump. Donc, ce que nous pouvons faire ici, c'est que nous allons mettre le texte ou les rappeler ici. Et puis nous allons aussi mettre la valeur que nous voulons couper loin du côté gauche. Donc, par exemple, si nous voulons couper le A, alors nous allons mettre VA ici. Et puis nous pouvons nous donner un alias, par
exemple, colonne coupée. D' accord, alors faisons-le ça. Et maintenant on peut voir, ok, on a notre compositeur. Et si nous avons notre colonne de garniture ici, nous avons tous les cas où il y a un à l'avant. Nous avons l'a coupé. Alors retirons notre déclaration de limite et regardons les résultats complets. Donc nous pouvons voir quand il y a, par
exemple, Angus Young, vous pouvez voir qu'il est enlevé quand il y a AC-DC, nous pouvons voir que l'A est enlevé. Et d'autres cas ici, encore une fois, l'a est enlevé. Donc, nous pouvons voir V L trim cherche ce personnage ici sur le côté gauche. Et s'il existe là, il va l'enlever. Maintenant, nous pouvons étendre cela plus. Et si nous mettons ici, par exemple, plusieurs caractères comme AC, alors bien sûr les résultats vont changer parce qu'Angus Young, par exemple, ne contient pas de C, mais le a est, nous pouvons voir ici est toujours coupé loin. Donc, il y a une quantité spécifique de coupe que nous pouvons faire est que nous pouvons voir
du côté gauche sur la chose importante à noter ici est que la coupe que nous faisons est sensible à la casse. Donc, si nous le mettons ici en minuscules a, alors rien ne se passera. Parce que encore une fois, nous faisons des choses sensibles à la casse. Nous devons donc nous rappeler
que ce que nous utilisons ici sera sensible à la casse. Maintenant, nous avons également bien sûr la possibilité de faire une garniture d'écriture et rtrim. Et prenons, par exemple, le n, sorte que le n à la fin de Johnson sera enlevé. Et donc si nous faisons ça, nous pouvons voir que tout cela est maintenant enlevé. Partout où il y a un n à la toute fin. Maintenant, je n'ai pas emporté. faisant défiler
ça, on dirait que Johnson est le principal. Vous pouvez donc voir les résultats ici. Tout cas où il y a un n à la fin, il n'est pas maintenant enlevé. Dans le cas où nous ne voulons pas spécifier si le navire B, la gauche ou la droite, et nous voulons juste supprimer les caractères supplémentaires de chaque côté. Ensuite, nous pouvons les faire en utilisant simplement trim. qui veut dire que ça va le faire, s'il trouve ce personnage de chaque côté, il va l'enlever. Donc, si nous courons, ces résultats vont toujours être principalement ce que nous avions auparavant, tout simplement parce que nous avons des résultats sensibles à la casse. Donc, dans ce cas, il est peu probable que l'un de nos compositeurs. Ici, nous allons commencer par un n minuscule, mais nous avons toujours la possibilité de l'enlever des deux côtés. Et ce que nous pouvons aussi faire, c'est que nous pouvons enchaîner les opérations. Par exemple, nous pouvons exécuter la garniture en premier, qui recherche le N de chaque côté en termes de loin. Et si nous le voulons, nous pouvons ensuite exécuter une coupe L sur les résultats. Donc, par exemple, disons que nous avons coupé le n. Et puis ce que nous voulons couper est, disons v a sur le côté gauche. Donc ce qu'on va faire, c'est d'abord nous allons lancer la déclaration ici. Et puis nous allons obtenir la colonne résultante ici, qui est, par exemple, ce que nous avions ici, Angus Young et puis le Johnson n'est pas arrivé n. Et puis nous
allons lancer la coupe L sur le résultat ici, cette fois cherchant à détourner la capitale a sur le côté gauche. Donc, pouvoir enchaîner ces opérations ensemble est bien sûr très agréable et très utile. Et dans certains cas, tu vas faire ça. Par exemple, si vos valeurs de date sont un peu foirées ou dans un format bizarre et qu'il y a peut-être espaces
supplémentaires ou un remplissage supplémentaire autour de certaines valeurs de texte. Et vous pouvez simplement vous débarrasser de tout ce qui n'est pas censé être là pour vous assurer que vos données sont dans un format plus standard. Donc, la plupart du temps, vous allez utiliser ceci pour faire une sorte de traitement sur votre colonne au cas où les données ont soit un remplissage bizarre autour d'elle. Ou vous voulez juste enlever choses inutiles qui ne devraient pas être là pour que vos valeurs soient réellement plus propres. Maintenant, deux autres choses cool que nous pouvons aussi faire pour traiter un peu nos textes, c'est que nous pouvons faire un peu de casting. Nous pouvons les mettre en majuscules ou en minuscules. Cela peut être vraiment sympa parce que depuis lors, beaucoup de fois, nous avons affaire à la sensibilité à la casse. Peut-être qu'à certains points, nous ne nous soucions pas vraiment si Angus Young est écrit majuscule un MGUS ou si c'est écrit en minuscules, un MGUS sont tous des majuscules ou des minuscules. Parfois, nous ne voulons pas vraiment faire face à ces choses sensibles à la casse. Donc, une bonne solution à cela est juste de tout lancer. Nous convertissons tout en majuscules ou en minuscules. Donc, pour ce faire, nous pouvons utiliser le mot-clé opera. Et nous allons juste mettre ici une colonne de compositeur à nouveau. Donnons à cela l'alias, et mettons un espace ici juste pour le rendre plus lisible en tant que compositeur supérieur. Et puis nous allons aussi lancer en minuscules,
ce que nous pouvons faire en utilisant le mot-clé inférieur, nouveau en utilisant la colonne du compositeur. Et puis cela nous pouvons avoir ici en tant que compositeur inférieur. Donc en cours d'exécution, nous pouvons voir ici maintenant nous avons la déclaration de terme que nous avions avant, la colonne d'origine, tout converti en majuscules et tout converti en minuscules. Donc, ici, nous pouvons, par exemple, également essayer après que nous avons tout converti en minuscules. Regardons à couper l'un des acides. Bien sûr, nous allons nous assurer que nous utilisons S en minuscules ici, puisque tout ici va être en minuscules. Donc ça devrait enlever le, si on jette un coup d'oeil ici, le S est à l'avant ici. Et puis nous avons aussi les routes de Taylor. Donc, le S à la fin devrait également être enlevé ici. Alors allons de l'avant et lançons ça. Et nous pouvons voir dans ce cas, les deux SS sont enlevés. Encore une fois, cela peut être vraiment utile quand il peut y avoir un remplissage ou d'autres
choses autour de vos données et que vous voulez faire un peu de traitement sur vos chaînes, en étant
juste capable d'enlever certaines de ces valeurs. Maintenant, nous pouvons combiner cela, par
exemple, à ce que nous avons appris avec le casting. Et disons que nous voulons enlever v dot 99 à tous, à la fin de chaque prix unitaire ici. Donc ce qu'on peut faire, c'est qu'on peut juste dire, d'accord, alors prenons notre prix unitaire et on va convertir ça en texto. Et puis ici, nous allons couper à partir du MOOC, notre coupe du côté droit, le point 99, puisque ce sera maintenant des valeurs de texte. Et puis si nous le voulons, nous n'avons pas à le faire, mais si nous le voulons, nous pouvons le convertir en un entier. Alors rappelez-vous que nous pouvons utiliser le double deux-points ou vous pouvez également utiliser l'instruction as. Et puis ici, nous pouvons faire le casting. Et pour montrer qu'il s'agit d'un entier, nous pouvons ajouter, par exemple, plus un. Et puis cette année, nous pouvons économiser comme prix unitaire coupé. Donc on peut faire ça et juste jeter un oeil sur le côté droit ici. Donc, ce que nous avons fait est de convertir ou un prix unitaire en texte, cette colonne ici en texte. Ensuite, nous avons dépouillé au point 99 sur le côté droit, qui a maintenant toutes les valeurs de texte. Ensuite, nous avons ramené cela à un entier et ajouté un à celui-ci. Ainsi, nous pouvons voir même dans les cas où nous ne traitons pas de données textuelles, nous pouvons toujours utiliser les autres parties de SQL que nous connaissons et combiner ces opérations ensemble. Donc, nous pouvons voir, par exemple,
ici, nous pouvons utiliser un bon casting pour ensuite faire cette opération cool, en convertissant entre le type de texte et ensuite en entier. Et puis pouvoir également utiliser, par exemple, les ajouts entiers ici. Et bien sûr, en fonction de votre situation, en fonction de vos besoins, vous pouvez obtenir avec nous. Vous pouvez également le faire dans les instructions de cas par exemple, ou aussi dans d'autres endroits. Donc, encore une fois, beaucoup de cela vous pouvez utiliser pour simplement traiter vos données pour vous assurer que vous pouvez les obtenir dans le bon format
dont vous avez besoin ou pour vous assurer que vous pouvez faire ce type de formatage ou être en mesure de changer les choses autour en fonction de vos besoins. Et bien sûr, parce que cela fonctionne sur le texte, vous pouvez toujours tout lancer dans le texte comme nous l'avons vu ici, et être capable d'effectuer techniquement les mêmes opérations sur des valeurs qui ne sont pas intrinsèquement des textes et ensuite simplement être capable de les convertir plus tard si vous le souhaitez. Donc, cela peut être vraiment agréable juste pour le traitement des données
générales pour vous assurer que vous obtenez les données et le format réel dans lequel vous vouliez les avoir.
28. 26StringPositionalInformationHB: Maintenant, dans certains cas, nous pouvons vouloir connaître des informations supplémentaires sur les tailles sont des composants de nos chaînes. Jetons un coup d'oeil à ces maintenant. Maintenant, il y a différentes façons de les utiliser, et nous allons juste les utiliser dès maintenant à des fins numériques de réalité virtuelle. Mais nous pouvons les utiliser un pour le côté analytique pour comprendre quels types de valeurs nous traitons. Mais nous pouvons également les utiliser pour, par exemple, les
changer en instructions de cas pour effectuer des opérations conditionnelles spécifiques. Alors écrivons notre squelette d'abord. Sélectionnez tout de la piste, limitant nos résultats. Cinq ici. Et ce que je veux faire, c'est que je
veux comprendre la taille de certains noms compte tenu de notre base de données actuelle. Alors prenons nos noms ici. Et je veux savoir combien de temps les noms d'axones peuvent obtenir, parce que peut-être nous avons attribué une taille et que nous voulons savoir si la taille du graphique à barres, par
exemple, nous avons assigné à notre colonne de nom ici est appropriée. Sommes-nous près d'atteindre la limite supérieure de cette taille de char var est beaucoup trop grande. Ou peut-être un autre but analytique que nous voulons connaître la longueur 4. Donc, pour ce faire, nous pouvons utiliser cette fonction appelée longueur. Nous pouvons le mettre dans la valeur que nous recherchons. Dans ce cas, nous allons regarder la colonne de nom. Et puis nous allons nous donner un alias comme longueur rurale, ou peut-être que nous pouvons appeler cette longueur de nom pour le rendre encore plus descriptif. Alors allons de l'avant et lançons ça. Et maintenant nous pouvons voir que cela va nous donner combien de caractères sont à l'intérieur de notre texte ici sur le côté de notre chaîne ? Combien de caractères individuels, y compris les espaces, y compris les parenthèses, y compris tout autre caractère spécial, combien de temps sont dans ce cas les textes que nous avons ? C' est donc le résultat que nous pouvons le faire. Alors peut-être qu'on ne veut plus ça. Mais ce que nous ne pouvons pas faire, c'est peut-être que nous voulons trouver la plus grande chose, donc nous voulons la voir dans l'ordre décroissant au moins. Donc, nous allons commander par la longueur du nom dans l'ordre décroissant. Donc si nous exécutons ceci, nous pouvons voir maintenant, d'accord, donc le plus grand nom dans ce cas a 123 caractères dedans. Et on peut voir qu'on en a trois sur une centaine. On en a environ 90 et ainsi de suite. Vous pouvez donc voir ici l'ampleur des choses qui vont. Nous pouvons également inclure cela si nous voulions une déclaration de cas. Donc, nous pouvons dire, n'oubliez pas de mettre des virgules entre des colonnes séparées. Cas. Lorsque la longueur, il suffit de garder cette majuscule de la colonne de nom est supérieure à 50. Ensuite, nous prenons la valeur 50 plus. Et puis la prochaine déclaration que nous pouvons avoir, lorsque la longueur de la colonne de nom est supérieure à 40. Ensuite, nous prenons 40 plus, ou nous pouvons dire 41 à 50. Et donc je ne vais pas écrire tout ça. Au lieu de cela, je vais juste le copier plusieurs fois et ensuite utiliser une indentation. Alors. Maintenant, quand la longueur est supérieure à 30 et que je dis de 31 à 40, celle-ci sera de 21 à 30, celle-ci sera de 11 à 20. Sinon, nous allons dire moins ou égal à 10,
mettant fin à notre déclaration de cas. Et puis ici, nous pouvons dire ceci par exemple, Comme le nom de la longueur du seau. Alors allons de l'avant et lançons ça. Et maintenant nous pouvons voir, d'accord, maintenant nous avons un aperçu encore plus rapide de, vous savez, dans quelle catégorie, par
exemple, cela tombe. Nous pouvons donc voir que nous pouvons également l'utiliser dans différentes positions. Donc, nous pouvons l'utiliser directement. Mais bien sûr, nous pouvons également l'utiliser à l'intérieur des déclarations de cas sont à l'intérieur d'autres choses, peu importe ce que nous recherchons. Maintenant, une autre chose cool que nous pouvons faire est que nous pouvons trouver des
positions de caractères s'ils existent à l'intérieur d'une chaîne. Et nous pouvons le faire en utilisant l'énoncé de position. Et puis ici par exemple, nous pouvons dire la sous-chaîne que nous recherchons. Donc, tout ce que nous cherchons ici dans le flux principal que nous cherchons. Par exemple, regardons la première occurrence de la lettre
a dans la colonne du compositeur. Mais convertissons cela en majuscules parce que nous ne voulons pas vraiment faire la différence entre les minuscules et les majuscules a est. Donc, nous cherchons juste la première position de la lettre a dans la colonne du compositeur où tout est converti en rois de cuivre. Et puis nous pouvons sauver ceci ou lui donner un alias comme position. Donc, si vous êtes sur ce, s'il y a une nouvelle, Bon, Si nous imprimons également la colonne du compositeur sur le côté afin que nous puissions également comparer les résultats. Donc on peut voir s'il n'y a pas d'intérieur, alors ça va nous abandonner. Maintenant, cette position, on commence à compter à un ici. Donc ça va être 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12. Donc, nous pouvons voir ici la première fois que l'IA apparaît, c'est en position 12 dans notre chaîne. Au cas où c'est 0, on peut voir qu'il n'apparaît pas du tout. Et puis dans d'autres cas ici, par exemple, nous pouvons voir qu'il se produit dans la position 1. Et ainsi de suite. De cette façon, nous pouvons rechercher soit une valeur spécifique, soit nous pouvons chercher, par
exemple, des sous-chaînes. Par exemple, nous pouvons chercher Angus. Chaque fois que cela apparaît complètement. Maintenant, pour tout ça, ça va être 0 jusqu'à ce que nous
trouvions trouvions l'instance où c'est Angus Young. Probablement préférable de le faire en ajoutant une déclaration où, année, où compositeur. Et je vais le faire, j'aime, même si nous pouvons le faire en minuscules, c'est plus agréable d'avoir en majuscules pour le rendre plus lisible. Il est semblable. Angus Young utilisait l'œil comme si on n'avait pas besoin de la capitalisation ici. Je vais le faire de toute façon, juste parce que c'est naturel de le faire. Donc on peut voir ici, ok, maintenant on peut utiliser le filtrage juste pour faire une vérification plus rapide. Et on peut voir RA. Donc la première fois qu'on voit Angus, la corde complète Angus ici en est un. Jamais bien, puisque nous avons fait ce filtrage là où vous ne le voyez nulle part ailleurs. Donc, nous pouvons aussi chercher autre chose. Par exemple, la première fois que nous avons été vus jeunes. Et encore une fois, juste pour le rendre plus facile, filtrons spécifiquement pour toutes les rangées où il y a des jeunes contenus à l'intérieur. Et encore une fois, nous utilisons l'œil comme si nous faisons un filtrage insensible à la casse ici. Et ici, nous pouvons voir par exemple, accord, donc la première position est sept. Donc 1, 2, 3, 4, 5, 6, 7. Donc la sous-chaîne jeune commence à la position 7 ici. Et donc nous pouvons voir cette fonction que nous pouvons également utiliser pour identifier des positions de départ spécifiques, ce qui peut être vraiment agréable à nouveau, comme nous pouvons le voir ici, la partie supérieure est également utilisée. Donc, nous pouvons voir beaucoup de ces fonctions peuvent être enchaînées ensemble, chacune fournissant un morceau du puzzle que nous pouvons ensuite utiliser avec d'autres fonctions pour faire un traitement de données ou d'autres composants dans nos requêtes SQL.
29. 27StringSubsetsConcatinationsHB: Très bien, donc nous avons beaucoup appris sur les chaînes maintenant et comment nous pouvons utiliser différentes fonctions pour obtenir des informations à partir de chaînes que nous avons dans nos colonnes. Mais les flux pour aller de l'avant et jeter un oeil à certaines choses plus cool que nous pouvons faire qui nous aideront spécifiquement à traiter nos données. Alors allons de l'avant et regardons notre colonne de piste à nouveau. Et la première chose que je veux regarder est de faire la concaténation de chaînes. Ce qui veut dire qu'on prend deux cordes ou qu'on peut même prendre plus de deux et qu'on peut les joindre ensemble. Donc, par exemple, commençons par joindre le nom et
le compositeur afin que nous obtenions une nouvelle colonne qui a la valeur qui est le nom de la chanson. Et puis on dit le compositeur après. Donc, par exemple, cela ressemblerait à ceux qui sont sur le point de rock, nous vous saluons, et après cela nous aurions le nom du compositeur. Donc, pour ce faire, allons juste de l'avant et d'abord écrire notre SQL squelette. Et ça va être la table de piste. Et allons-y et limitons nos résultats à cinq. D' accord, on va utiliser le nom du compositeur. Alors allons de l'avant et extrayons-les, juste pour que nous puissions bien sûr comparer nos résultats. Ce qu'on veut faire, c'est prendre la colonne des noms pour l'instant. Et à cela, nous voulons ajouter le compositeur. Prenons notre colonne de nom. Et maintenant, nous voulions simplement ajouter sur la colonne du compositeur à la fin. Donc, la façon dont nous pouvons faire cette concaténation de chaîne est simplement en utilisant ces lignes verticales doubles. Donc nous allons mettre notre première chaîne ici, qui dans ce cas va faire référence au nom de la colonne. Et maintenant, nous allons mettre notre deuxième corde ici, qui dans ce cas va faire référence au compositeur de colonne. Et puis ce qu'il va faire, ça va prendre tout ce qu' il y a ici et à la fin,
il va se joindre à tout ce qui est ici. Alors donnons un nom à ça. Nous allons couper cela, appeler ces colonnes concat, boucle colonnes concat pour les colonnes concaténées. Et allons-y et continuons ça et voyons à quoi ça ressemble. D' accord, donc nous avons notre première colonne de nom ici. Ensuite, nous avons notre compositeur, et maintenant nous avons notre résultat ici, qui est littéralement juste le nom. Et puis vous pouvez voir dès qu'il se termine sont compositeurs ici commencer. Et nous pouvons aussi voir que pour d'autres choses, dans le cas où nous n'avons pas de valeurs, le résultat final, comme nous pouvons
le voir ici, sera également une valeur connue. Bien sûr, le format que nous avons maintenant ces données n'est pas particulièrement utile. Alors allons-y et rendons un peu plus agréable à regarder en ajoutant un espace après le nom de la colonne. Et puis nous disons au revoir, puis nous disons le nom du composant. Donc pour ce faire, nous allons juste mettre ici l'espace de cordes. Et puis on va avoir Bye. Et puis on aura un espace. Et puis on peut juste ajouter des lignes verticales tumorales. Et soudain, nous faisons plusieurs concaténations différentes. D' abord, on prend la colonne de nom. Ensuite, à la fin, nous ajoutons de l'espace par espace. Et puis on fait une autre concaténation. À la fin de cela, nous ajoutons maintenant la colonne du compositeur. Donc, si nous allons de l'avant et exécutons ça, nous pouvons voir maintenant, d'accord, les formats que plus nous avons le nom, alors nous avons acheté, et ensuite nous avons ici les compositeurs eux-mêmes. Maintenant, nous pouvons faire encore plus ici. Alors prenons ça tout le chemin et commençons par la piste. Et puis on va mettre la carte d'identité du camion. Et puis nous allons donner le nom de la chanson. Et puis on va donner au compositeur. Alors avant ça, on va dire « Track ». Et puis maintenant, nous voulons avoir la piste IT. Alors, comment pouvons-nous faire ça ? Donc, pour ce faire,
Ce qui est cool à ce sujet, c'est que nous pouvons en fait, tant que nous sommes entre les deux ici, également mettre des valeurs entières. Donc, nous pouvons simplement référencer directement la colonne ID de piste et la concaténation de chaîne. On va s'occuper de la conversion pour nous. Et pour rendre ce formatage un peu plus agréable, je vais mettre un deux-points et un espace ici. Et donc si nous exécutons ceci, nous pouvons voir ici maintenant nous avons suivi et ensuite nous avons l'ID, et maintenant nous avons notre colonne de nom activée. Alors allons de l'avant et juste ajouter un autre espace ici juste pour un formatage et réexécutez cela. Et donc nous pouvons voir même si notre ID de piste est en fait un entier, que nous pouvons également voir quand nous le regardons ici. La concaténation de chaîne prendra soin de la conversion pour nous. Mais bien sûr, si ce ne serait pas aussi savoir comment faire la conversion nous-mêmes en utilisant le casting, par exemple, simplement en le jetant à une valeur de texte. Donc, au cas où ça n'aurait pas été pris en charge pour
nous, on pourrait le faire comme ça. Et bien sûr, il s'en occuperait pour nous. Ou nous pourrions le transférer à un autre type de données que nous trouvons plus approprié. Mais comme nous pouvons le voir, la concaténation de chaîne. En fait, il s'occupe de tout ça pour nous. Maintenant, bien sûr, c'est généralement dans la direction opposée de l'endroit où nous aimerions aller. Habituellement, nous pouvons avoir des données comme celle-ci et ensuite nous aimerions aller dans ce format. Mais néanmoins, voir simplement la concaténation de chaîne est vraiment agréable car à un moment donné, vous voulez l'utiliser et à bon usage. Et dans ce cas, nos bases de données très propres bien sûr, euh, mais dans certains cas, vous pouvez avoir des moments où vous avez, par
exemple, nous allons jeter un oeil à la colonne de facture. Il peut y avoir des moments où vous avez la date et l'heure dans deux colonnes distinctes. Et vous voulez juste les joindre ensemble et les utiliser comme une valeur de date complète. Donc, vous pouvez faire la concaténation de chaîne pour obtenir une date plus l'heure. Ensuite, vous pouvez faire un casting à un datetime par exemple. Et puis à partir de là ont directement le datetime et une colonne. Donc, selon la façon dont vos données sont formatées, parfois les colonnes que vous utiliseriez ne sont pas dans le format idéal pour lequel vous aimeriez qu'elles soient. Soit pas d'analyse supplémentaire sur la ligne ou juste un traitement que vous voulez faire, ou aussi juste pour avoir une exportation plus propre en ayant moins de colonnes. Et donc la concaténation de chaînes peut être vraiment agréable parce que, comme nous pouvons le voir, nous sommes capables de regrouper différentes colonnes, ainsi que d'ajouter des douanes. Nos propres cordes sont toutes réunies. Et bien sûr, remarquez encore ici que les textes personnalisés que nous avons sont entre guillemets simples. Et toute référence aux colonnes ici est entre guillemets doubles. Maintenant encore une fois, nous avons besoin des guillemets doubles parce que par créer une table, les noms de colonnes étaient à trouver avec des guillemets doubles. Lorsque notre table n'est pas définie avec des guillemets doubles pour utiliser les colonnes, alors nous pourrions également simplement référencer la colonne directement comme ceci. Mais nous ne pouvons jamais utiliser de guillemets doubles pour les chaînes. n'y a que réservés pour les noms de colonnes, comme nous l'avons vu sont également des noms de table dans ce cas, comme nous pouvons également le voir en fonction de la façon dont l'instruction create table a été écrite. Bon, alors maintenant on a regardé et on a rassemblé les choses. Allons dans la direction opposée et regardons réduire les choses. Donc je vais enlever ça juste pour qu'on n' plus
une très longue sortie ici. Et la prochaine chose que nous allons examiner est d'utiliser ou trouver des sous-chaînes d'une chaîne que nous avons. Jetons donc un coup d'oeil à une, juste l'implémentation la plus simple d'abord pour trouver la sous-chaîne. Nous allons aller et utiliser cette méthode de sous-chaîne, sous-chaîne. Et puis ici, nous pouvons ouvrir et fermer les parenthèses. Et puis la première chose que nous voulons mettre est
le texte ou la chaîne à partir de laquelle nous voulons prendre la sous-chaîne. Par exemple, prenons la colonne du compositeur. Et puis nous voulons mettre ici où nous voulons commencer. Donc, nous pouvons dire, par exemple, à partir de la position 1 dans SQL, la première position sera toujours la position
1 au cas où vous savez à quel autre langage de programmation vous pourriez être habitué. La première position étant appelée position 0. Mais en SQL, la première position est la position un. Et si vous ne connaissez pas un autre langage de programmation, alors bien sûr, c'est très intuitif que la première position serait référencée comme position un. Donc de toute façon à partir d'un et le premier personnage ici va être à la position un. Et maintenant, vous voulez dire combien nous voulons en extraire. Donc, pour ce faire, nous voulons dire, disons que nous voulons extraire les cinq premiers. Donc on va dire à partir de 145. Donc ce que ça veut dire, c'est qu'on va prendre la sous-chaîne. Donc nous allons prendre une plus petite partie de la chaîne de tout ce qui est mis ici. Et on va commencer à la première position. Et on va prendre cinq personnages. Et donnons un pseudonyme à ça. Donc nous pouvons appeler cette sous-colonne, et allons de l'avant et lançons ça. Et donc nous pouvons voir ici, nous commençons par Angus par exemple, et nous allons, Nous commençons à la position 1 mai aller pour 1, 2, 3, 4, 5. Elle peut voir ici. Regardons la suivante. Ballon F Tez. Nous commençons donc à la position 112345. Et donc vous pouvez voir que c'est aussi exactement ce que nous avons ici. Maintenant, il y a en fait une autre façon que nous pouvons aussi faire la syntaxe à partir de laquelle vous n'avez pas réellement besoin d'écrire. Et quatre peuvent également utiliser des virgules, une séparation à la place. Donc, par exemple, vous pouvez juste mettre ici la chaîne et ensuite nous pouvons mettre une virgule. Et ce sera le point de départ, et ce sera le nombre de valeurs que nous voulons extraire. Donc, si nous allons de l'avant,
nous pouvons voir que nous obtenons exactement le même résultat. Et en fait, nous n'avons même pas besoin des quatre dernières valeurs. Donc, les quatre dernières valeurs n'est même pas nécessaire. Et nous pouvons aussi l'enlever,
à ce moment nous allons juste. Commencez à prendre toute la chaîne à partir de la position de départ. Donc nous pouvons voir ici, dans ce cas, nous commençons à la position 1. Donc on prend tout. Si nous commençons par la position 5, par exemple, alors nous continuerons seulement à partir de la position 5. Donc 1, 2, 3, 4, 5. Donc, à partir de ce personnage, nous allons prendre tout ce que nous pouvons voir ici. Maintenant, même dans cette méthode, nous pouvons utiliser les résultats d'autres méthodes que nous avons appris précédemment. Par exemple, Essayons d'extraire les cinq premiers caractères après avoir rencontré le premier espace. Donc, pour ce faire, tout d'abord, nous devons trouver la position du premier espace. Et nous pouvons le faire en utilisant la méthode de position que nous avons apprise auparavant. Donc, nous allons trouver le poste. Et tout d'abord, nous allons mettre ici le compositeur. Et nous voulons trouver la position du premier espace. Et puis nous allons extraire les cinq prochains caractères. Mais puisque nous voulons commencer après le premier espace, plutôt qu'au premier espace, nous devons également en ajouter un au résultat ici. Depuis la position du premier espace, nous allons faire un départ exactement sur l'espace. Mais nous voulons commencer à un après cet espace. Donc on va en ajouter un ici. Alors allons de l'avant et lançons ça. Maintenant aussi cette déclaration, nous pouvons faire plus intelligent
en utilisant d'autres fonctions que nous avons également appris à l'avance. Par exemple, essayons de trouver les cinq premiers caractères après le premier espace que rencontre le compteur. Donc, pour ce faire, tout d'abord, nous devons trouver la position du premier espace. Nous pouvons le faire en utilisant la fonction de position que nous avons apprise plus tôt. Donc on peut dire position. Et maintenant, vous voulez trouver la position de l'espace dans notre colonne compositeur et tapez 2. N' oubliez pas d'utiliser la fonction de position. Nous voulons donc trouver la sous-chaîne de la colonne du compositeur. Et nous voulons commencer à la position ou plutôt après la position. Et nous y arriverons dans une seconde après la position du premier espace. Donc, pour obtenir l'après, cela nous donnera la position du premier espace. Et cela signifierait que nous allons commencer par là. Mais si nous voulons prendre la position après le premier espace, et nous devons en ajouter un à notre résultat ici. Et puis nous voulons extraire les cinq premiers caractères. Et donc, et ça va être les cinq ici. Et maintenant encore une fois, ce que nous faisons c'est que nous trouvons ces cordes Trump ou affinons une sous-chaîne et la couleur du compositeur. Donc, chaque ligne va à nouveau avoir une valeur différente. Et nous allons commencer à la position du premier espace plus un. Donc on va commencer un après le premier espace, et ensuite on va extraire cinq caractères. Donc, si nous faisons ça, nous pouvons voir ici ce sont les résultats que nous obtenons. Et nous allons enlever notre déclaration de limite et voir à quoi il ressemble pour tout. Plus précisément. Pour les cas où il n'y a pas d'espace comme un AC, DC ici. Ou voyons s'il y en a un autre dans ce cas ici. Donc, vous pouvez voir dans ces cas, nous commençons juste à la valeur initiale, puisque la position de l'espace et du compositeur, il n'y a pas d'espace. Et donc cela va nous donner 0. Donc, si nous exécutons ceci séparément et nous économisons cela comme position de l'espace et sont sur la seconde. Ainsi, vous pouvez voir la position de l'espace dans ce compositeur nommé par exemple, il n'y a pas d'espace, et donc cela va nous donner 0. Et donc le plus comme nous allons juste commencer par le caractère un, c'est pourquoi, par
exemple, nous voyons ici commencer comme ça et y par exemple, pour CDC. Nous voyons aussi plus juste pris les cinq premiers ici, ce qui va en fait nous donner le nom complet du compositeur en raison de la position de l'espace ici va être 0. Et donc nous allons commencer à la première position, puisque nous faisons le plus 1 ici. Maintenant, nous pouvons rendre cela encore plus compliqué si nous le voulions à nouveau, en utilisant les mêmes méthodes sont les mêmes fonctions que nous avons eu auparavant. Et faisons cela,
divisons cela sur plusieurs lignes pour ne pas l'avoir aller trop loin dans l'horizontale. Donc ce qu'on va faire, c'est trouver le premier mot après le premier espace. Ainsi, par exemple, nous voulons tout trouver entre le premier et le second espace. Donc, dans ce cas, il va être jeune virgule, ou ici il va être boulon a virgule. Alors, comment pouvons-nous faire ça ? Eh bien, maintenant nous devons rendre ce composant intelligent ici ou vous devez le rendre dynamique. Donc d'abord ce qu'on veut faire, c'est tout trouver après le premier espace. Et puis nous voulons tout trouver jusqu'à l'espace suivant. Donc, nous allons commencer par trouver tout dans le premier espace, ce que nous avons déjà fait ici. Donc on peut juste prendre ça, on peut copier ça et mettre ça ici. Mais puis fermez nos parenthèses puisque nous voulons tout
prendre après le premier espace. Maintenant, nous avons déjà fait cela parce que exactement ceci ici, cette partie de notre requête ici extrait, eh bien, dans ce cas, nous extrayons les cinq premiers caractères, mais nous pourrions tout aussi facilement supprimer cela. Et maintenant, nous extrayons tout après le premier espace. Donc, nous voulons prendre cela cependant comme entrée. Donc, ce que nous allons faire est plutôt que d'utiliser notre colonne compositeur ici, ou plutôt la chaîne correspondant à la ligne actuelle de la colonne compositeur. Nous allons plutôt utiliser le résultat de ceci. Et donc on va juste ici, on peut voir ça. Nous voulons juste nous assurer que toutes nos parenthèses sont bien fermées. Donc, notre premier élément ici, et nous allons juste ajuster notre espacement pour rendre cela plus lisible. Nous pouvons voir que le premier élément ou la première valeur, et à part ici est le résultat de cette déclaration. Et ça va tout nous donner après le premier espace. Donc maintenant, dans ce cas, par exemple, nous allons avoir des jeunes et ainsi de suite, parce que nous ne limitons pas les caractères. Maintenant, la prochaine chose qu'on veut faire est de tout trouver jusqu'au prochain espace. Donc, parce que nous savons que nous commençons après le premier espace, notre personnage de départ ici peut être juste un. Puisque nous commençons directement après le premier espace, ce qui signifie que nous voulons toujours commencer par le mot suivant. Mais maintenant, nous devons trouver la position finale, qui va changer en fonction de la longueur du nom. Par exemple, young a cinq caractères dans le nom Malthus F6. Et dans chacun de ces cas, nous avons en fait une virgule derrière. Et jusqu'où nous voulons aller pour atteindre le deuxième espace va à nouveau changer. Donc ce que nous pouvons faire, c'est que nous pouvons dire, accord, eh bien, nous avons déjà ceci ici. Fondamentalement, nous voulons juste aller à la position de l'espace suivant, mais plutôt monter à la position de l'espace suivant et compositeur, qui va être la position du premier espace. Nous devons à nouveau utiliser le résultat de cette déclaration ici. Donc, mettre ceci ici et juste mettre ceci à nouveau sur une nouvelle ligne pour que tout soit plus facile à refaire. D' accord, alors allons de l'avant et donnons une course à ça. Et jetons un oeil à notre résultat. Donc ce que nous pouvons voir c'est maintenant que nous obtenons exactement ce que nous voulions, qui est jeune une virgule biotas et ce quiz, c'est juste une AMD. Alors passons à travers cela une fois de plus parce que cette structure est un peu complexe. Il y a beaucoup de composants imbriqués ici. Donc, notre première valeur, la chaîne à partir de laquelle nous prenons la sous-chaîne, est en fait le résultat de la prise de la sous-chaîne de la colonne du compositeur commençant après la position du premier espace, ce que nous avons fait plus tôt. Donc, par exemple, pour notre première rangée ici, ce serait juste jeune et tout après cela, puisque nous ne limitons pas jusqu'où nous allons. Donc, la prochaine chose que nous faisons alors en utilisant ce résultat est que nous commençons à la position 1. Depuis que nous, avec ça, nous commençons après le premier espace. Et nous voulons aller à la position de l'espace suivant. Donc, la position de l'espace suivant va alors être deux ou plutôt pour obtenir correctement cela, nous devons encore utiliser le résultat ici. Et de cette façon, nous pouvons alors utiliser les jeunes et ainsi de suite. Et maintenant, nous devons trouver la position de l'espace suivant, parce que si nous venons d'utiliser la colonne du compositeur original, alors cela nous donnera juste la position du premier espace dans la colonne complète. Mais nous ne voulons pas cela parce que nous utilisons déjà une partie de sous-chaîne de cette colonne. Donc, nous voulons nous assurer que lorsque nous utilisons la fonction de position ici, nous utilisons le même substrat. Donc encore une fois, nous allons trouver la position de la première chaîne dans le résultat de l'instruction de sous-chaîne que nous avons écrite ici, qui va être la même que nous utilisons ici. Maintenant, en fait, il y a une subtilité ici, qui est que nous avons en fait un espace de fin en plus des virgules de fin que nous avons dans certains cas. Et maintenant on pourrait essayer de dire, d'accord, on va monter à la position moins un pour se débarrasser des espaces de fuite. Mais le problème est dans certains cas quand il n'y a plus d'espaces dans notre sous-chaîne. Par exemple, ici, notre résultat ici va être 0. Donc, nous allons déjà aller pour 0 longueur, ce qui est pourquoi, par exemple ici AC, DC, nous avons rien de plus cool pris un pas de caractères. Et si nous mettons une valeur négative, vous pouvez voir ici que dans ce cas, postgres se plaint parce que nous ne sommes pas autorisés à mettre des valeurs négatives. Ici, nous pouvons prendre des quantités négatives de texte ou des quantités négatives de caractères. Mais nous connaissons déjà la solution ou nous
connaissons déjà la fonction que nous pouvons utiliser pour résoudre ce problème. A savoir, nous allons utiliser la méthode trim. Et ici, je vais juste utiliser le bon atout parce que nous voulons spécifiquement couper le côté droit. Et ce que nous voulons faire, c'est que nous voulons couper la virgule de fin et aussi l'espace de fin. Nous allons mettre fin à notre fonction ici et juste
le mettre sur la même ligne juste pour avoir tout et syntaxe. Et allons de l'avant et lançons ça. Et maintenant, nous pouvons voir que nous nous sommes débarrassés de la virgule de fin
ainsi que de l'espace de fin qui est réellement caché. Et si nous avions juste une virgule ici, sont les résultats ne changeraient pas parce que nous avons cet espace de fin abord que nous ne pouvons pas voir dans ce cas à cause de l'apparence de la sortie. Donc soyez conscient de cela, que dans ce cas, nous aurions un espace d'entraînement et une virgule de fin. Maintenant, comme il peut l'espérer, même si certaines des fonctions du Postgres peuvent sembler un peu semblables. Par exemple, pourquoi devrions-nous connaître la position selon laquelle il ne doit pas y avoir beaucoup de cas d'utilisation. Mais le truc cool est que vous pouvez utiliser toutes ces fonctions ensemble. Et à travers cela, vous pouvez réellement écrire des trucs de traitement assez cool. Et vous pouvez voir que nous pouvons sorte de résultats d'imbriquer ici et utiliser les résultats d'une sous-chaîne comme point d'entrée d'une autre sous-chaîne. Donc, il y a beaucoup de choses cool que nous pouvons faire en chaînant différentes fonctions ensemble utilisent les résultats pour faire un traitement de données vraiment agréable. Même dans ce cas, si la tâche était seulement de retirer la première valeur après le premier espace et entre, entre le premier espace et le deuxième espace plutôt. Donc, nous pouvons voir ici cependant, il y a encore une fois, choses vraiment sympa que nous pouvons faire en utilisant juste plusieurs de ces différentes fonctions ensemble afin que nous puissions obtenir ino, un traitement unique et personnalisé où tout est un peu juste l' adaptation aux valeurs d'entrée que nous avons. Et nous n'avons pas besoin de coder spécifiquement longueurs spécifiques sont des points de départ ou quelque chose comme ça. Comme nous pouvons le voir ici, ces deux valeurs que nous avons renvoyées ne sont pas très différentes longueurs. Mais c'est totalement bien parce que notre requête prend soin de tout et cela ne se soucie pas vraiment de combien de temps chacun d'entre eux sont, parce qu'il a aussi pris soin de automatiquement à l'intérieur.
30. 28StringReplacementsHB: Et nous avons déjà bien regardé beaucoup de choses que nous pouvons faire avec des chaînes en SQL. Mais il y a une chose de plus cool et utile que je veux vous montrer, qui remplace les valeurs dans les chaînes. Donc, nous allons tout d'abord écrire notre code squelette ici. Facilité, nous avons quelque chose. Et dans ce cas, nous allons réellement utiliser la colonne de facture parce que je veux utiliser cette colonne de date ici. Nous allons donc sélectionner dans cette colonne de facture. Limitons nos résultats à cinq d'abord. Et ce que je veux faire, je veux remplacer cet espace ici à la place par un T. Maintenant, il y a différentes façons que différents programmes et temps d'
écriture y a-t-il différentes façons que différentes personnes peuvent mettre en forme des sujets ? Donc, parfois quelque chose que vous verrez est un T ici, ou vous verrez des barres obliques ici. Maintenant, SQL a un format très spécifique qu'il veut, que vous pouvez également voir ici, année, mois, jour avec des tirets entre eux. Et vous avez l'espace, et ensuite vous avez des heures, des minutes, des secondes. Et puis ici, vous avez les composants millisecondes. Et vous pouvez voir tout cela est que les sous-champs sont séparés par des deux-points. Et ici, nous avons un séparé par un point. Et donc nous pouvons également regarder dans la table des factures d'honneur. Et nous pouvons voir ici la date de facturation dans ce cas est en fait un horodatage. Mais la valeur que nous voyons comme les utilisateurs en quelque sorte rendu convivial pour nous. Et c'est en fait la plus belle représentation de cette valeur d'horodatage. Et nous pouvons également utiliser ce résultat directement. Mais parce que différents programmes et parfois même des personnes différentes formatent les dates différemment. Et c'est le format SQL que vous voulez, mais vous ne pouvez pas toujours l'obtenir parce que parfois, si les données sont juste téléchargées à partir du résultat d'une chaîne de vacances d'un horodatage, alors parfois la façon dont ce programme met cet horodatage ou cette date dans une chaîne et peut ne pas être le format réel dont vous avez besoin. Alors regardons juste une chaîne de placements. Même si nous avons déjà la valeur que nous voulons ici. En utilisant les remplacements de chaîne, vous pouvez, si l'autre format général est le même, vous pouvez déjà obtenir des valeurs vraiment agréables. Nous pouvons vraiment aller au format dont vous avez besoin. Alors, tu as fait ça ? Modifions simplement cette date de facture ici pour habiter le capital T entre ici, qui sont la chose courante que vous pourriez voir à un moment donné. Donc, pour ce faire, nous allons sélectionner date de la
facture et nous allons la sélectionner pour que nous ayons à comparer. Et maintenant, pour faire le placement réel, nous allons utiliser la fonction Remplacer. Et gardons cette majuscule. Et la syntaxe que nous voulons utiliser ici est d'abord, nous voulons mettre la chaîne complète que nous allons utiliser, qui dans ce cas, il va juste être avec le résultat de la date de facturation, alors nous voulons avoir la valeur que nous voulons remplacer. Donc, par exemple, dans ce cas, et remplacons l'espace. Et puis nous avons la valeur par laquelle nous voulons la remplacer. Par exemple, remplacons-le par la majuscule T. Et puis donnons à ceci un alias à la date modifiée. Maintenant, il y a en fait une autre subtilité que nous devons prendre en charge,
qui est notre date de facture est un horodatage interne. Mais quand nous le regardons,
il est en fait converti pour nous en la représentation textuelle de cet horodatage, qui le rend bien sûr beaucoup plus facile à lire. Il est beaucoup plus facile de lire la date réelle avec l'année, mois, le jour, les heures, les minutes , les
secondes, plutôt que de regarder juste un tas de chiffres qui représentent un temps. Donc, ce que nous devons faire pour le faire correctement, c'est que nous devons
également convertir cet horodatage en un format de texte. Et allons de l'avant et faisons la conversion ici. Et continuons aussi et faisons la conversion en interne. En fait, ne faisons pas ça ici parce que je veux vous montrer le résultat de ses deux, mais nous devons l'avoir ici parce que sinon nous les regardons, ce sont en fait des valeurs horodatées. Donc, il y a des horodatages, mais nous devons les convertir en une représentation textuelle d'un horodatage,
qui, lorsque vous le faites en SQL, ressemble à ceci. Sinon, nous ne serons pas en mesure de l'utiliser correctement. Donc, si nous allons de l'avant et exécutons ceci, nous pouvons voir ici que c'est le résultat que nous obtenons lorsque nous le convertissons au format texte, qui est fondamentalement tout après le point ici, qui dans ce cas n'est pas utilisé juste parce qu'il n'est pas présent. Et puis nous avons l'espace ici remplacé par le thé. Donc, nous pouvons voir que c'est le SQL ou la présentation que nous voyons quand nous avons des valeurs d'horodatage, mais nous ne faisons aucune autre conversion. C' est ainsi qu'ils sont montrés à l'utilisateur dans ce cas. Et nous le ferions en fait, si nous voulons lancer ceci dans un texte, nous pouvons voir ici ceci est le casting résultant que nous avons qui sont exactement
la même valeur parce que nous n'avons pas de composants supplémentaires de millisecondes ici. Mais il est toujours agréable d'être conscient de cette différence subtile que vous allez obtenir lors conversion en colonne horodatage en type de données texte. Juste parce que cela change légèrement l'apparence de la sortie, mais cela affecte également vraiment la façon dont nous allons utiliser ces valeurs. Donc, nous pouvons voir parfois nous pouvons obtenir des dates, valeurs de
date ou des valeurs de datetime qui ont cette équipe entre, qui dans ce cas, nous pouvons effectivement enchaîner. Et on va s'enchaîner. Parce qu'en réalité, traitons simplement l'exemple que nous obtenons cette valeur à l'intérieur. Donc, nous allons enchaîner nos opérations ici. Mais en réalité, nous avons juste pris
une sorte de colonne de date modifiée et puis nous allons supprimer ce ET de base, OU ce t. Nous allons donc remplacer du résultat de cette déclaration de remplacement ici, qui est ce que nous voyons ici. Donc, si c'était une vraie entrée et que nous voulons enlever le thé, puisque ce genre de le met dans le format esco que nous devons l'utiliser comme ID, date, heure, ou comme horodatage. Donc on va remplacer ça et on va le remplacer. Et mettons ceci sur une nouvelle ligne pour l'instant. Nous allons remplacer le T et nous allons le
remplacer par un espace et l'interminable. Et il est aussi de donner le nom de la colonne ici à nouveau. Donc, si on fait ça, on peut voir qu'on récupère la valeur exacte. Mais encore une fois, ce que nous avons fait c'est que nous avons remplacé l'espace ici par le t. Et puis nous avons remplacé le réveil de T. Et parfois, vous verrez que, vous savez, il peut y avoir des cas où vous avez juste des dates qui ressemblent à ceci. Maintenant, il y a quelques bases de données SQL qui peuvent traiter avec ce format. Par exemple, postgres est l'un d'entre eux où nous pouvons toujours prendre cela et le convertir en un type horodatage. Et nous pouvons voir si nous faisons tout ça, courir, tout ça. On peut voir ici qu'on le convertit en horodatage. Mais généralement la formule SQL correcte que vous voulez comme un espace entre ici, car toutes les bases de données SQL ne peuvent pas traiter ces valeurs T comme ceci. Et donc dans certains cas, la déclaration peut réellement planter. Et donc sachez qu'il existe une sorte de SQL idéal pour toujours sans vous voulez,
qui est l'année, le mois, le jour,
l'espace, les heures, les deux-points minutes, les deux-points secondes. Et la raison pour laquelle vous l'avez comme ceci est parce que même si ces valeurs sont des chaînes, si vous les triez,
elles vont toujours être triées dans le bon ordre. Et c'est aussi pourquoi il est important que nous ayons ce format d'année, de mois, jour et de jour NADH, mois, année ou mois jour, année ou quelque chose du genre. Avoir ce format très spécifique rend tout très standard. Donc, dans ce cas, nous pouvons voir dans Postgres, le T majuscule n'est pas un problème, mais ce n'est pas vrai pour toutes les bases de données. Et SQL est un peu très variable. Et bien sûr, si vous finissez par avoir à porter, peut-être que vous utilisez plusieurs bases de données SQL différentes. La déclaration peut faire plus d'un d'entre eux et peut planter et l'autre parce que encore une fois, ils ont abordé ce était légèrement différent. Alors soyez conscient de cela. Idéalement, vous voulez opter pour ce format propre. Et bien sûr, vous pouvez utiliser tous les remplacements et pièces moulées. Et c'était des sous-chaînes et tout le reste que nous avons appris, tous les trucs de traitement pour modifier toutes les colonnes et les mettre dans le bon format afin que vous puissiez faire la conversion de type. Mais sachez simplement que vous pouvez
rencontrer parfois avoir des colonnes de date et des formats incorrects. Et un autre qui est couramment vu est, par
exemple, avoir des tirets, barres obliques au lieu de tirets. Donc un autre pas aussi souvent vu est, um, commencer à convertir ceci en horodatage pour que nous puissions réellement voir le résultat. Mais un autre qui est généralement considéré comme bourdonnant comme des tirets ici ou quelque chose comme ça. Alors sachez simplement que ce sont des choses que vous pouvez rencontrer. Et ce cas, comme nous pouvons le voir, parce que le casting de l'horodatage a fonctionné à nouveau, mais d'autres bases de données SQL peuvent ne pas être si géniales pour s'adapter à ces différents formats. Donc, sachez simplement que nous pouvons utiliser les méthodes de remplacement simples ainsi d'autres méthodes de chaîne que nous avons utilisées pour traiter ou manipuler des données à l'avance pour obtenir nos données dans le bon format.
31. 29DateAndTimeHB: Maintenant, une information de date et d'heure comme nous avons également ici dans la colonne de date de facture est susceptible d'apparaître sous un formulaire ou un autre très souvent dans vos tables SQL car il est vraiment agréable de garder une trace de quand les choses se sont produites. Jetons donc un coup d'oeil aux dates et heures et comment nous pouvons les utiliser pour en extraire quelques informations. Juste parce que ce sera un champ commun à voir. Maintenant, ce qui est vraiment agréable, c'est que SQL est vraiment bon pour
traiter les informations de dates et d'heure. Et, et c'est génial parce que cela nous donne beaucoup de flexibilité. Donc, continuons simplement et écrivez
d'abord un relevé de sélection squelette à partir de notre tableau de factures, limitant nos résultats 25. Et encore une fois, nous l'avons déjà vu auparavant, mais continuons simplement et sélectionnons la colonne de date de facturation. Et on va aller de l'avant et faire ça. Et nous pouvons voir ici c'est une sorte de textes ou de présentation que nous ne pouvons pas revenir à nous dans notre table parce que la valeur elle-même a un horodatage. Et nous avons aussi vu que si nous jetons ceci à une valeur de texte, nous pouvons simplement l'obtenir sans le composant milliseconde dans ce cas parce qu'il n'est pas inclus. Mais disons que nous sommes seulement intéressés par l'utilisation de la date, par
exemple, nous ne sommes pas particulièrement intéressés par l'utilisation de l'heure. Disons que nous voulons faire une analyse où nous voulons voir, d'accord, j'ai besoin de comprendre quand les choses se passent jour après jour seul, ou peut-être même pas cette taille. Mais je ne suis pas super intéressé par la composante temps ici. Donc, ce que nous pouvons faire est d'utiliser notre date de facturation. On peut juste lancer ça à un rendez-vous. Alors allons de l'avant et peut-être donnons à ceci un alias comme date. Donc nous pouvons exécuter ceci et nous pouvons voir ici, ce sera juste notre genre de sortie initiale. Et si nous retirons simplement le composant date, nous pouvons voir que nous découpons très facilement la date et nous pouvons faire des choses avec la date. Et nous pouvons aussi, par
exemple, prendre le temps. Parce que peut-être, disons, peut-être disons que nous sommes seulement intéressés à
faire une analyse en regardant un moment précis des jours. Et nous ne sommes pas très intéressés par les jours et la date ici, mais plutôt nous sommes plus intéressés à regarder l'heure de la journée parce que nous voulions comprendre les fluctuations avec l'heure de la journée ou quelque chose comme ça. Donc, nous pouvons voir ici dès que nous l'avons dans le format d'horodatage approprié ou dans le format d'heure de date approprié. Nous pouvons alors très facilement en extraire les informations dont nous avons besoin. Et nous pouvons également l'utiliser pour le filtrage. Donc, par exemple, prenons d'abord notre déclaration de limite pour que nous obtenions le résultat complet. Disons que nous sommes intéressés à analyser un comportement basé sur l'heure de la journée dans la semaine. C' est entre, qui commence à partir de la première ligne de 2000 et va jusqu'à la sixième de la première. Donc, nous pouvons faire est dans notre clause où, nous pouvons dire où la date de la facture est entre. Et ici on peut dire, on va prendre la chaîne 2019, euh, 11. Ce que nous pouvons lancer à une date et à la fin. Je n'ai pas besoin de ces parenthèses entre ça. Et puis aussi ici, ce que nous allons avoir cette 2000 et qui je voulais écrire neuf ici maintenant 192 mille ligne et puis un 1 et 0, 6. Et encore une fois, nous allons convertir ça en un rendez-vous. Donc, si nous allons de l'avant et exécutons ceci, nous pouvons voir ici très facilement, nous pouvons faire le filtrage de date et nous pouvons également faire le temps spécifique au jour pendant. Parce que SQL comprend intrinsèquement les formats de date et d'heure, ce qui est bien sûr vraiment utile car les valeurs de date et d'heure apparaissent si souvent. Et plus récemment, ou plus généralement, vous vous souciez de ce qui s'est passé récemment, pas autant que ce qui s'est passé cinq ans dans le passé, bien sûr, vous voudrez peut-être avoir accès à cette information. Mais la plupart du temps, lorsque vous essayez d'accéder à des informations ou d'effectuer une analyse, vous êtes le plus intéressé par les données les plus récentes. Et donc avec SQL, nous pouvons très facilement le faire en utilisant simplement les valeurs de date inhérentes,
les valeurs temporelles inhérentes, ainsi que la valeur d'horodatage, car elles sont toutes compatibles les unes avec les autres. Maintenant, il y a aussi une autre chose cool, qui est cette fonction appelée maintenant. Maintenant, ce que cela fait, c'est qu'il donne fondamentalement la date et l'heure actuelles. Alors allons de l'avant et lançons ça. Et nous pouvons voir ici le résultat ici va être le même parce qu'il ne renvoie qu'une seule valeur, mais il donne la date et l'heure actuelles en heure UTC. Donc, nous pouvons voir qu'il donne la date exacte et la valeur de l'heure en UTC. Et nous pouvons également l'utiliser à nouveau ici pour en extraire des valeurs. Par exemple, pour obtenir la date actuelle, nous pouvons simplement faire maintenant et ensuite utiliser le résultat. Et à partir d'ici, il suffit d'extraire la date. Et nous pouvons enregistrer ceci comme date actuelle. Et donc notre colonne de date actuelle ici, par exemple, ce sera juste ce que nous voyons ici, la date actuelle. Maintenant, nous pouvons également l'utiliser pour le filtre. Par exemple, nous pouvons dire, d'accord, allons trouver tous les endroits où la date de facture est supérieure ou égale à ou patinoire. Dans ce cas, cela aura plus de sens. Mais disons ou le composant devs de la date de facture est égal à la date d'aujourd'hui, ce que nous pouvons faire. Maintenant, dans ce cas, nous ne allons pas recevoir de valeurs, bien sûr,
parce que les données ici sont anciennes et il n'y a rien de ce genre de se rapprocher de la date d'aujourd'hui comme nous pouvons le voir. Mais nous pouvons toujours utiliser le filtrage dynamique comme celui-ci. Intérêt sorte que nos requêtes s'adaptent en fonction de la date et que les choses changent, nos données vont toujours rester à jour parce que nous utilisons cette fonction interne MAINTENANT, qui nous donne juste la date et l'heure actuelles. Ensuite, nous pouvons extraire, par exemple, la date et, vous savez, obtenir des informations de date à partir de là. Et bien sûr, parce que SQL comprend et utilise correctement les valeurs de date et d'heure, nous pouvons faire toutes sortes de comparaisons et regarder des plages et toutes sortes de choses cool.
32. 30DateTimeIntervalsHB: Non plus de pouvoir simplement extraire les
valeurs de date et d'heure et être capable de faire des comparaisons et d'autres choses. Sql a également une option vraiment cool de nous pouvoir utiliser des intervalles de temps. Alors jetons un coup d'oeil à ça. Laissons simplement notre relevé de sélection de squelette ici, sélectionnez dans notre tableau de factures, limitant nos résultats à cinq. Allez-y et exécutez ça. Maintenant, essayons de sélectionner ou plutôt essayer de trouver d'abord la différence horaire entre la date actuelle d'aujourd'hui et la date de facture ici. Nous allons donc extraire la date de la facture afin que nous ayons la valeur de comparaison. Et puis nous allons utiliser notre maintenant pour nous donner le courant à la date et à l'heure. Et maintenant pour obtenir un intervalle, tout ce que nous avons à faire est de soustraire la date de la facture, qui a un horodatage. Donc, parce que ces deux sont compatibles avec l'horodatage, nous pouvons maintenant prendre notre valeur nulle, ce qui nous donne également un horodatage et soustraire de la date de la facture. Et ici, nous pouvons appeler cela, par exemple, comme le temps depuis la facture. Et si nous exécutons ceci, nous pouvons voir ici c'est notre date de facture et cette année est la différence de temps depuis la voix. Donc, par exemple, nous avons vu ici, est-ce que nous voyons dans ce cas, il est environ 4 200 jours depuis ces factures demi-passées en fonction de la date exacte. Maintenant, nous pouvons également convertir ces valeurs, par exemple, valeurs
de date, car nous
obtenons actuellement des informations sur les heures, les minutes et les secondes. Nous pouvons également les convertir à ce jour. Donc, si nous voulons et dans quel cas nous allons juste obtenir directement des dates, di
sombres, des différences, comme nous pouvons le voir ici. Donc c'est une façon dont ce genre d'intervalle apparaît. Nous pouvons obtenir des différences d'intervalles entre les différents moments. Mais bien sûr, ça ne s'arrête pas là. Nous pouvons également utiliser des intervalles. Alors jetons un coup d'oeil à ça. Prenons tout d'abord notre colonne de facture et notre colonne de date de facture, et ajoutons simplement un peu de temps. Donc bébé, nous ne voulons pas avoir ou nous ne voulons pas montrer les données en UTC. Nous n'avons pas stocké en interne en UTC, mais quand nous le
retirons, nous voulons passer à un fuseau horaire séparé. Par exemple, passons à UTC plus 1. Alors, comment pouvons-nous ajouter une heure sur la date de facturation de la tournée ici ? Eh bien, c'est vraiment facile parce que tout ce qu'on a à faire c'est faire plus ici. Et maintenant, nous avons cette option d'intervalle et SQL. Et l'intervalle. Maintenant, nous mettons juste ici une chaîne de la quantité de temps que nous voulons ajouter. Par exemple, nous voulons ajouter une heure. Et ici, nous pouvons enregistrer cela comme, par
exemple, ajouter une heure. Donc, si on fait ça et qu'on enlève ça pour l'instant, ça
entrave le chemin. Donc, si nous exécutons ceci, nous pouvons voir que c'est notre état d'entrée d'origine et c'est notre date de facturation avec une de nos vérifications. Donc, ce qui est bien, c'est que nous avons nos valeurs datetime en interne, comme vous pouvez le voir, nous pouvons toujours faire toutes sortes de conversions de timeline. Et une fois que nous le retirons et le rendre approprié à tout ce que nous voulons montrer, bien sûr sont beaucoup d'options juste à ajouter sur une heure, mais nous ne pouvons vraiment pas faire tout ce que nous aimerions, par exemple, pour plutôt nous allons renommer notre colonne d'abord. Donc, ici, nous pouvons dire ajouter du temps. Ajoutons 1. Deuxièmement, la tendance. Fais-le comme ça. Vous pouvez le faire et réfléchir une minute. Nous pouvons ajouter un mois, nous pouvons ajouter un an, ou nous pouvons égaliser sur plusieurs années. Si vous voulez ajouter plusieurs années, vous pouvez soit faire deux ans ou vous pouvez également mettre un S ici comme nous pouvons le voir, leurs résultats eux-mêmes ne changent pas. Mais c'est bien parce que nous pouvons utiliser cette valeur d'intervalle maintenant pour avoir un intervalle de temps que nous spécifions à travers la chaîne ici. Maintenant, ce que nous pouvons aussi faire, par exemple, disons que nous voulons les ajouter deux ans et un mois. Exécutez ça. Et nous pouvons voir que tout adopte à deux. Donc, l'instruction d'intervalle ici est cool. Et c'est cool de pouvoir l'utiliser dans l'instruction select, mais c'est encore plus cool de pouvoir l'utiliser à l'intérieur de notre filtrage. Alors jetons un coup d'oeil à cela et sélectionnons ou prenons ou déclaration. Et débarrassons de notre limite pour l'instant. Et aussi juste se débarrasser de ce ici et faire ce que nous allons filtrer par. Je veux donc ajouter 15 ans à notre date de facturation. Et maintenant, je veux filtrer par où notre date de facture plus l'intervalle de tous. Faisons de nous tous des capitaux juste pour indiquer à nouveau, c'est l'instruction SQL. De plus, l'intervalle de 15 ans est supérieur à la date et l'heure actuelles. Donc, si nous exécutons ceci, nous pouvons voir dans ce cas nous allons obtenir toutes les valeurs retournées parce que si nous
ajoutons 15 ans à la date de facturation que nous allons être en 2024. Et donc nous pouvons voir, bien sûr, dans ce cas, tout va dépasser la date et l'heure actuelles. Maintenant, c'est une façon de le faire. Une autre façon de le faire, ou de le filtrer est, disons que nous voulions trouver toutes les factures de la semaine dernière. Donc, ce que nous pouvons faire ici, c'est que nous pouvons également utiliser des intervalles de l'autre côté. Donc, disons notre tout d'abord, prenons ce chemin juste pour un peu utiliser les colonnes comme nous les trouverions dans des tables régulières. Donc, disons que notre table de dates de facturation est toujours en cours de mise à jour et que nous voulons trouver toutes
les factures au cours de la dernière semaine afin que nous puissions entendre dire tout droit. Prenons la date et l'heure actuelles et soustrayons l'intervalle de sept jours. Donc nous cherchons tout au cours des sept derniers jours. Et pour que nous puissions exécuter ça. Dans ce cas, nous ne recevrons rien parce que c'est arrivé il y a toujours. Nous pouvons donc le faire ici, par exemple, comme nous le pouvons encore. Dans ce cas, nos résultats ne vont bien sûr pas changer de routage depuis tant d'années. Mais vous pouvez voir ici en imaginant que notre date de facture a été constamment mise à jour. Nous pouvons faire en sorte que nos requêtes s'adaptent aux intervalles de temps actuels, ou nous pouvons trouver des plages de temps spécifiques soit en prenant la date et l'heure actuelles, en décollant sept jours. Nous pouvons lancer ceci à une date pour nous assurer que les informations d'heure ne sont pas entrées et ensuite décoller sept jours. Et de cette façon, nous pouvons faire un très beau filtrage pour regarder, par exemple, les choses qui se sont produites
les sept derniers jours et les choses qui se sont produites les 10 derniers jours, choses
qui se sont produites au cours des dernières 24 heures, les choses qui est arrivé au cours des cinq dernières heures. Nous pouvons avoir un intervalle de temps vraiment personnalisé à utiliser pour le filtrage. Et c'est vraiment bien parce que la plupart du temps, lorsque nous utilisons des données qui ont une sorte d'horodatage attaché à elle. Nous n'allons pas utiliser toutes les données à travers le temps. La plupart du temps, nous ne nous intéressons qu'à des régions temporelles spécifiques. Et donc nous pouvons voir avoir cette option pour être en mesure d'utiliser des intervalles soit
pour faire des comparaisons avec la date et l'heure actuelles ou à la date actuelle, ou définir des intervalles de temps en utilisant cette instruction d'intervalle ici, nous pouvons vraiment faire des instructions de sélection personnalisées qui nous donnent
juste des données pour exactement les périodes qui nous intéressent.
33. 31HB: Maintenant, une autre chose très importante sur l'écriture de requêtes, ou aussi sur l'écriture de code en général est de laisser des commentaires. Parce que lorsque vous lisez quelque chose et si cela devient complexe, Il est vraiment agréable d'avoir des commentaires ou des annotations qui expliquent ce que vous faites ou ce que vous pensez ou ce que cette partie est quatre, sorte que lorsque vous revenez plus tard ou lorsque d'autres personnes ont essayé de le lire, elles comprennent le processus de réflexion et ce qui se passe ici. Parce que parfois, si vous écrivez une requête plus complexe ou un code plus complexe, puis vous le laissez juste pendant quelques mois, puis vous
essayez de revenir quand vous essayez de
comprendre ce que vous avez fait exactement à chaque point et pourquoi c'est ici en Ohio, il a ce format et pourquoi vous avez peut-être fait le tour spécial. Avoir laissé un commentaire est une façon vraiment agréable de
guider les gens à travers lui afin qu'ils puissent comprendre votre processus de pensée, la façon de penser et pourquoi, par exemple, spécifique qui a été fait ou tout ce que vous pourriez vouloir écrire à l'intérieur. Jetons donc un coup d'oeil à la façon dont nous pouvons écrire des commentaires. Et nous allons juste utiliser une simple déclaration de requête ici à partir de notre tableau de factures. Et en limitant nos résultats à cinq, juste parce que c'est une déclaration de squelette de visage à avoir. Alors allons de l'avant et laissons quelques commentaires. Laisser quelques commentaires très basiques devient néanmoins. Donc, la première façon de laisser des commentaires est d'utiliser un double tiret. Et puis tout ce que nous écrivons après ce tableau de bord va être commun. Bien. Mettez un espace ici pour qu'il devienne plus lisible. Par exemple, ici, nous pouvons dire la sélection des colonnes. Et si nous faisons ça, alors vous verrez qu'on a tout rendu. Et même si on enlève l'espace ici, tout fonctionne toujours. Les commentaires ne font pas partie de l'exécution, mais nous pouvons les laisser ici. Nous pouvons voir que ceux-ci ne s'étendent pas sur les lignes suivantes comme nous pouvons le voir parce que cette partie de l'instruction SQL est toujours en cours d'écriture. Cependant, si nous n'avions pas séparé ou instruction SQL sur plusieurs lignes, alors tout après cela sur la même ligne va être commenté, auquel cas nous allons maintenant avoir un problème. Donc c'est aussi, c'est agréable d'avoir toutes les choses divisées sur plusieurs lignes. Maintenant, dans ce cas, comme vous l'avez peut-être vu, Databricks fait des commentaires intelligents, où si vous avez un commentaire et que vous ajoutez une nouvelle ligne quelque part, il ajoute automatiquement ce tiret numérique à l'avant, qui dans la plupart des cas vraiment sympa dans ce cas quand nous essayions de revenir à notre requête et bien sûr, ce n'était pas ce que nous essayions de faire. C' est une chose qui est spécifique à la prise de données et pas spécifique à Postgres. Quoi qu'il en soit, nous pouvons utiliser des déclarations communes comme celle-ci. Et relancez cette nouvelle fois pour se débarrasser de l'avertissement. Nous pouvons donc utiliser des instructions KMS comme celle-ci pour annoter notre code ou nos requêtes. Donc, nous pouvons nous asseoir ici, par exemple, en sélectionnant à partir de la table des factures. Bien sûr, dans ce cas, nos commentaires sont assez triviaux et pas particulièrement utiles. Mais au fur et à mesure que le processus de pensée se tourne, peut-être que vous laissez un commentaire au début d'une partie plus complexe de la requête. Et puis vous pouvez voir que cette partie fait ça. Vous n'avez pas besoin d'annoter chaque ligne, mais simplement dire comme ce bloc suivant est responsable ceci ou lorsque vous avez une logique spécifique quelque part là-dedans, nous utilisons, par exemple, des instructions de position pour trouver des intervalles. Vous pouvez dire que le format de données R est comme ceci, c'est pourquoi nous pouvons utiliser l'hypothèse pour trouver la position de ceci, pour trouver cette valeur suivante. Vous savez, juste en expliquant votre processus de pensée de cela quand les gens viennent le voir ou le renouveler, y revenir quelques mois plus tard parce que peut-être vous n'avez pas besoin de changer en ce sens que vous pouvez toujours comprendre et vous n'avez pas besoin d' essayer de décomposer les requêtes et comprendre et de récapituler le processus de pensée que vous êtes venu il y a quelques mois. Donc oui, nous pouvons écrire une seule ligne vient là-haut, nous pouvons aussi les écrire sur des lignes séparées. Par exemple, un nouveau commentaire de ligne. Donc, ce sera un commentaire qui se produit sur une nouvelle ligne. Et encore une fois, tous ces commentaires qui commencent par S double tiret ne couvrent que des lignes simples. Nous pouvons également avoir des continents multi-lignes. Maintenant, une façon dont nous avons vu que nous pouvons faire est que nous pouvons simplement étendre et partager sur plusieurs lignes et avoir plus de lignes ici. Mais ce n'est pas très efficace. Parce que si vous voulez écrire sur plusieurs lignes, vous ne voulez pas avoir tous ces tirets là-dedans. Donc, ce que nous pouvons faire à la place, c'est que nous pouvons utiliser un format qui ressemble à une étoile slash avant. Et puis cela commence le commentaire multi-ligne. Et nous pouvons terminer le commentaire avec une barre oblique avant à nouveau. Et puis juste enlever les déclarations ici parce qu'il n'est plus moins que nécessaire. Et maintenant, nous pouvons voir maintenant nous avons un commentaire multi-ligne. Donc, tout entre cette slash avant étoile et slash avant étoile, tout cela va être commenté et demander des commentaires aller. Nous pouvons voir que si nous faisons cela, nos résultats ne changeront évidemment pas. Maintenant, avec cela, eh bien, nous pouvons même faire est que nous pouvons peu commun entre les déclarations. Par exemple, nous pouvons dire ici sur le point de dire la table, puis se terminant ou commun à nouveau. Et nous pouvons exécuter ceci, et cela va toujours fonctionner parce que rien de tout cela ne fera partie de la requête finale réelle qui va être exécutée. Tous les commentaires qui soulagent ici sont juste pour faire nos requêtes ou si vous l'utilisez ailleurs. Et le code est les commentaires en général sont là pour rendre le code plus lisible, pour expliquer votre processus de pensée, pour expliquer la logique. Encore une fois, le point de commentaires est de ne pas commenter chaque ligne, en particulier comme le commun trivial qui se sont engagés ici en sélectionnant nos colonnes, en sélectionnant dans la table des factures. Mais c'est plutôt si vous entrez dans une partie qui n'est pas évidente et qui peut causer une certaine confusion. Il est bon de laisser juste un commentaire pour expliquer dans ce commun peut être plus court, peut être long en fonction de combien d'explication est nécessaire juste pour expliquer ce qui se passe ici. Donc, c'est quelqu'un qui peut être nouveau, qui voit la requête pour la première fois. Vous revenez un mois, deux mois, six mois, un an plus tard à la même requête peut encore très rapidement comprendre et en quelque sorte de comprendre l'essence de la requête. Comprenez ce qui se passe dans chaque partie et qu'ils ne le
traversent pas et qu'ils ne sont pas perdus par ce qui se passe sur une partie spécifique. Et puis ils doivent passer du temps à essayer de comprendre, ok, alors qu'est-ce que cette partie de la requête fait exactement ici et pourquoi est-ce comme ça et pourquoi y a-t-il toutes ces conditions spéciales ? De cette façon, Mino, avoir des commentaires peut rendre la vie de tout le monde beaucoup plus facile.
34. 32AggregationHB: Maintenant, ce qui est vraiment cool à propos de SQL, c'est que les requêtes peuvent aller bien au-delà de la simple sélection de colonnes et de lignes spécifiques et de faire des opérations sur les lignes, ce qui est déjà très cool. Mais nous avons aussi des options pour faire toutes sortes d'agrégations. Jetons un coup d'oeil à ça maintenant. Allons à nouveau dans notre table de piste. Et regardons spécifiquement cette colonne millisecondes et regardez-les, essayez d'obtenir des informations agrégées à ce sujet. Par exemple, que faire si nous voulons trouver le temps moyen d'un solide ou le temps le plus long ou le plus court. Ou si nous voulons juste des informations comme le nombre de valeurs dans cette colonne ? Jetons un coup d'oeil à certains d'entre eux. Nous allons d'abord écrire notre déclaration de sélection de squelette, en sélectionnant à partir de la table de camion et en limitant nos résultats à 5 plus juste un peu vous voir, c'est le tableau que j'aime sélectionner. Bon, donc nous allons essayer d'abord de trouver la moyenne des millisecondes pour le patient. Donc, pour ce faire, nous pouvons utiliser une fonction appelée ou désignée AVG pour la moyenne. Et si nous mettons ici à l'intérieur de la colonne millisecondes, alors nous allons obtenir une valeur retournée, qui sera la durée moyenne. Nous savons que c'est la durée parce que c'est un peu ce que la colonne milliseconde donne. Mais c'est juste la moyenne de la colonne millisecondes. Donc nous pouvons nous donner une meilleure moyenne d'alias de milli secondes. Et donc cela va être la valeur moyenne de notre colonne millisecondes. Nous pouvons aussi faire d'autres choses. Par exemple, nous pouvons trouver le temps le plus long. Donc, nous pouvons trouver le maximum de la colonne millisecondes, que nous pouvons voir ici. Ce sera ici le temps le plus long que nous ayons dans cette colonne millisecondes ici. Et c'est notre valeur ici. Nous pouvons également trouver le temps le plus court en prenant le minimum. Somme, mettre à jour notre nom ici nous allons avoir le minimum. Et ici, nous pouvons voir que c'est le temps le plus court que nous avons dans nos valeurs de camion pour le temps en millisecondes. Nous pouvons également utiliser une, une autre fonction d'agrégation où nous pouvons résumer toutes les valeurs dans une colonne, par exemple. Donc, nous pouvons tout résumer en millisecondes, ce qui sera le temps total de toutes les pistes. Donc, résumer toutes les valeurs de cette colonne millisecondes ici va nous donner ce résultat ici comme nous pouvons le voir,
maintenant, il y a une autre fonction cool que nous avons, qui est le nombre. Maintenant, le compte ici, nous allons mettre une colonne et il va compter le nombre d'occurrences que nous avons. Donc ça va juste nous donner un compte du nombre de valeurs que nous avons. Ainsi, par exemple, nous pouvons mettre ici la colonne millisecondes. Et cela va nous dire le nombre d'instances en millisecondes. Et si nous exécutons ceci, nous pouvons voir dans ce cas nous avons 3.503 instances différentes. Donc 3,503 valeurs ici. Ce ne sont pas des valeurs uniques. Ce ne sont que des instances différentes dans ce cas, ou la table a été un peu coupée à 500 juste parce qu'elle ne veut pas montrer trop. Mais nous pouvons en fait, nous pouvons réellement voir ici pour vous dans leur filtrage par exemple, nous avons plus de valeurs disponibles. En fait, nous avons 3.503 lignes où ces valeurs à trouver. Maintenant, la raison pour laquelle je dis spécifiquement le nombre d'instances en millisecondes et parce que quand il y a des valeurs nulles, cela affecte le nombre. Jetons donc un coup d'oeil à une certaine valeur est où nous savons qu'il n'y a pas de valeurs, qui est la colonne du compositeur. Donc, comptons le nombre d'instances que nous avons et l'espoir et la colonne compositeur comme nombre d'instances et compositeur et exécutons ceci et regardant les résultats ici, nous voyons que nous avons 2525 lignes qui ne contiennent pas de valeurs nulles. Alors que pour les millisecondes, nous avons 3.503 lignes qui ne contiennent pas de valeurs nulles. Que diriez-vous si nous voulons juste obtenir le nombre total de lignes sans avoir à vous soucier de savoir si une colonne peut ou ne peut pas arriver, aucune valeur à l'intérieur. Eh bien. Et deux façons communes de le faire. L' un d'eux met juste une étoile à l'intérieur. Cela va être le nombre total de lignes et le début va juste juste pour nous laisser compter tout. Donc, nous pouvons voir ici, si nous le regardons, nous avons 3.503 lignes sans une ancienne valeur. Nous pourrions également mettre l'entier ici,
et il va juste en compter un pour chaque ligne qu'il a. Et pour que nous puissions voir que nous allons obtenir le même résultat ici. Nous pouvons donc utiliser la fonction de comptage sur les colonnes, auquel cas nous allons compter le nombre de lignes où nous avons une valeur inconnue, que nous pouvons voir sont différentes en fonction des différentes colonnes. Par exemple, dans le compositeur, où nous avons des valeurs nulles, ce nombre est inférieur. Ou on peut mettre une étoile ou le numéro d'un ici. Et cela va juste compter pour nous le nombre total de lignes que nous avons, comme nous pouvons le voir ici. Maintenant, nous pouvons, bien sûr, encore faire un tas d'autres trucs cool aussi, ou des colonnes. Par exemple, nous allons d'abord utiliser quelques arithmétiques simples et tourner ou millisecondes en deux minutes, minutes fractionnées. Donc la première chose que nous allons faire est juste diviser ou millisecondes par mille. Ça va nous donner le Sung que quelques secondes. Et puis nous allons le diviser par 60, ce qui va nous donner la longueur de la chanson en quelques minutes. Alors allons de l'avant et lançons ça. Et si nous faisons défiler vers la gauche, nous pouvons voir ici la longueur moyenne de la chanson en bleu. Ce cas, ça va prendre quelques minutes, c'est juste un peu plus de six minutes. Donc 6.05, qui est 606, ce qui est maintenant pas six minutes et secondes. Mais cette valeur va ici entre 01. Donc c'est 0,6 sur un. Donc ça va être une fraction qui est ici. Donc nous pouvons voir, nous pouvons toujours faire des choses à nos colonnes à l'intérieur et ensuite utiliser les agrégations dessus. Et bien sûr, nous allons juste appeler la fonction sur
le résultat final que nous avons à l'intérieur ici.
35. 33GroupementAndasFilterFilterAggregationsHB: Donc, nous venons de voir les agrégations et les agrégations sont cool. Mais ce qui est encore plus cool que les agrégations par différents groupes. Donc, ce que cela signifie, c'est, disons que nous voulons connaître le nombre de chansons que chacun des compositeurs qui ont écrit. Actuellement, ce que nous devrions faire est que nous pouvons utiliser la fonction count, que nous pouvons compter le nombre de lignes que nous avons. Ensuite, nous allons devoir filtrer pour chaque compositeur, pour chaque compositeur différent. Mais SQL peut en fait aller bien au-delà. Et ce que nous pouvons faire, c'est que nous pouvons créer des regroupements par chaque entrée différente que nous avons ici. Et puis nous pouvons obtenir des agrégations pour chacune de ces différentes entrées que nous avons. Maintenant, cela va être spécifique à l'utilisation des agrégations et il y a quelques exigences spécifiques, mais regardons cela. Faisons la première tâche ne peut pas être abordée, qui est de sélectionner pour trouver le nombre de pistes que nous avons pour chaque compositeur différent ici. Donc, en commençant par notre déclaration de squelette, en sélectionnant toutes les colonnes de la table de camion et limitant nos résultats à Phi d'avoir un point-virgule à la fin ici pour une bonne pratique. Et nous pouvons le voir bien. Ce sont donc les cinq premiers résultats sur notre table. D' accord ? Donc maintenant, ce que nous voulons avoir est, tout d'abord, comptons le nombre de lignes que nous avons. Et donc cela va juste être notre nombre de lignes, que vous pouvez voir ici est 3.503. Ok, mais comment peut-on regrouper ça par les différents compositeurs que nous avons ? Eh bien, nous pouvons faire est qu'il y a une déclaration cool que nous pouvons utiliser appelé et groupe BY. Et ici, nous pouvons mettre la ou les colonnes que nous voulons regrouper par. Par exemple, nous allons regrouper par la colonne du compositeur. Et maintenant, si nous exécutons ça, nous pouvons voir ici que nous obtenons différentes valeurs de comptage. En fait, on ne sait pas à quoi ça fait référence. C' est bon. On peut juste sortir notre compositeur colonne 2. Et nous pouvons montrer la chronique de notre compositeur. Et nous pouvons montrer le résultat du compte. Et nous pouvons voir ici, ok, Donc quand le compositeur est John Dolan, vous voyez que nous avons COUNTIF un et que le compositeur est ceci, vous avez un compte d'un, et ainsi de suite. Donc, vous pouvez voir ici nous obtenons les différentes valeurs pour les différentes entrées que nous avons compositeurs. Et si nous voulons, nous pouvons supprimer la déclaration de la
femme et voir le résultat complet pour tous les différents compositeurs. Donc, vous pouvez voir ici quelques compositeurs que nous avons plus d'entrées pour. La plupart sont beaucoup d'entre eux pour lesquels nous avons juste une entrée. Donc, dans ce cas, il dépend vraiment du compositeur est que nous pouvons voir ici. Maintenant bien sûr, nous pouvons également utiliser notre instruction de commande BY et moins d'ordre et aussi nous donner un alias comme nombre de pistes. Et nous allons commander par un certain nombre de pistes, par un certain nombre de pistes dans l'ordre décroissant, sorte que nous obtenons le plus grand nombre d'abord. Donc relancer ceci, faire défiler vers le haut, d'
accord, donc le plus grand nombre est en fait ceux où vous n'avez pas de valeurs. Après cela, nous avons Steve Harris, U2, jogger, Slash Richards, et ainsi de suite. Donc vous pouvez voir ici maintenant pour chaque compositeur que nous avons, nous savons aussi combien de pistes dans ce cas nous avons pour eux dans notre table. Maintenant, nous pouvons également ajouter du filtrage pour cela, et il existe deux types de filtrage différents. Allons d'abord avec une base 1 et sortons simplement tous
les cas où le compositeur est nul. Alors où va-t-on mettre ça ? Parce que nous nous souvenons de plus tôt que l'ordre que nous avons des instructions, et il est en fait important pour une requête SQL. Et nous devons nous assurer que tout est dans le bon ordre. Maintenant, l'endroit où cela a été aller est entre la déclaration de départ et le groupe BY. Donc, nous allons dire où le compositeur n'est pas nul. Et maintenant, lançons ceci et nous pouvons voir ici maintenant le cas nul a disparu, mais aucune des autres valeurs ici n'a changé parce que nous regroupons les compositeurs acheteurs ici. Maintenant, il est important encore que nous ayons la bonne commande. Parce que par exemple, si nous prenons ça et nous le mettons ici, alors ça ne fonctionnera pas. Nous devons donc nous assurer que notre ordre des instructions que nous
utilisons dans notre requête SQL est correct. Très bien, donc nous avons regroupé par ou compositeurs et nous avons filtré les cas où le compositeur n'est pas nul. Et maintenant, nous avons le résultat pour chaque compositeur. Nous avons le nombre de pistes que nous avons pour eux dans notre base de données. Alors que se passe-t-il si nous essayons de sélectionner une colonne ici que nous n'avons pas regroupée par. Par exemple, que se passe-t-il si nous essayons également de sélectionner la colonne de nom, qui contient le nom de chaque piste. Donc si on fait ça, on va avoir une erreur. Parce que dès que nous utilisons ce groupe par instruction, nous utilisons ces agrégations. Nous ne pouvons pas avoir ici des colonnes qui ne sont pas une agrégation elles-mêmes ou qui utilisent l'instruction group by here. Donc, pour pouvoir montrer la colonne de nom, nous devrions en fait regrouper par compositeur et par nom. Maintenant, si nous exécutons ceci, nous verrons que ce n'est pas particulièrement utile car il devrait être que nous n'avons qu'un seul enregistrement. Et vous pouvez voir dans certains cas ici nous en avons plus. Mais ce que nous attendons ici, c'est que, vous savez, les chiffres ici vont être petits et il y a, vraiment, il n'
y a pas beaucoup de praticité à regrouper, mais des compositeurs dans des noms. On peut voir que ça marche vraiment. Ainsi, la façon dont ce groupement fait son premier, nous regroupons par compositeur. Et puis au sein de chaque compositeur, nous avons regroupé par nom de la chanson. Donc, si nous avons deux compositeurs qui ont écrit une chanson du même nom, ce ne sera pas que les deux compositeurs seront regroupés,
mais plutôt nous regrouperons d'abord par compositeurs, puis au sein de chaque compositeur nous avons regroupé par nom. Et puis nous avons notre agrégation, regroupement d'acheteurs ici. Si nous changeons la commande, puis boucle, alors dans les cas où deux compositeurs ont écrit le même nom de chanson, alors nous verrions ce genre de reflet ici. Dans ce cas, nous avons encore quelques exemples de ces cas parce que nous nous souvenons que nous avons plusieurs disques où le compositeur est de Paris et où le nom réel est Rothschild. Mais nous obtiendrions aussi des résultats supplémentaires parce que nous pouvons avoir juste, si nous enlevons cette colonne du compositeur ici, si deux chansons ont le même nom, alors elles le seraient. Et maintenant, nous devons prendre le compositeur d'ici, puis ils seraient regroupés dans le même segment. Donc, c'est une chose importante à être au courant, que la commande, et prenons ceci, nous allons retirer ceci à nouveau. L' ordre du regroupement que nous faisons a un effet sur le résultat final. Et donc le regroupement fonctionne en prenant la première déclaration, ce sera le premier groupe au sein de ce groupe. Nous avons ensuite le prochain regroupement. Donc, cela va faire le deuxième groupe, et puis ainsi de suite. Donc, par exemple, essayons de faire usage de cela d'une manière plus pratique. Et essayons de trouver le nombre de pistes que nous
avons pour chaque compositeur, pour chaque album. Donc, nous voyons ici nous avons une colonne d'ID d'album. Nous allons d'abord regrouper par compositeur, puis regrouper par ID d'album. Et donc nous allons aussi montrer l'ID de l'album ici. Et donc ce que nous pouvons avoir maintenant, c'est que nous avons les résultats, qui est pour chaque compositeur, euh, et pour
cet album spécifique, c'est le nombre de pistes que nous avons pour ce compositeur et cet album. Et on peut vraiment être différent. Nous pouvons voir ici que nous avons le même compositeur, mais nous avons deux albums différents. Et ces cas, ce sont des identifiants d'album que nous pouvons trouver, par exemple, dans la colonne supérieure, nous avons ici la carte de l'ID d'album au nom réel de l'album lui-même parce que c'est une bonne pratique d'utiliser entiers et d'autres endroits de sorte que si le titre change ou quelque chose, vous n'avez pas à mettre à jour toutes les bases de données, mais seulement les informations où elles sont stockées. Donc nous pouvons voir ici, nous avons les identifiants d'album qui représentent un album spécifique. Donc, dans ce cas, nous avons un compositeur dont nous avons deux albums pour et pour l'album 55 de ce compositeur, nous avons 20 titres et l'album 54 de ce compositeur, nous avons 17 titres. Bien sûr, nous n'avons pas seulement besoin de faire l'agrégation de comptage ici. Nous pouvons aussi en faire d'autres. Par exemple, nous pouvons l'appeler, peut faire tous ceux que nous avons vus précédemment. Par exemple, il a la moyenne des millisecondes ici. Donc, comme longueur de chanson, et puis nous allons avoir une autre colonne qui nous donne la longueur moyenne de chaque album pour chaque compositeur. Donc nous allons d'abord regrouper par compositeur. Ensuite, nous allons regrouper mon ID d'album pour chaque combinaison d'albums compositeurs. Nous allons alors avoir le nombre de camions ainsi que la longueur moyenne de la chanson. Et nous supprimons cette faute de frappe ici. Et donc nous pouvons voir que c'est ce que nous avons pour quand le compositeur est JC Fogarty. Et puis l'ID de l'album est 55. Ici, nous avons 20 titres pour cela dans notre base de données avec une longueur moyenne de 224 mille millisecondes dans ce cas. Donc, nous pouvons voir ici dans ce cas, nous n'avons pas besoin d'ajouter la colonne millisecondes dans l'
instruction group by car elle fait partie de l'agrégation. Tant que nous avons des agrégations ici, alors c'est bon. Mais les seules colonnes que nous sommes autorisés à sélectionner, soit les colonnes qui sont incluses dans l'instruction group by, ou si les résultats des agrégations autrement, comme nous l'avons vu précédemment, nous allons obtenir une erreur. Alors que se passe-t-il maintenant si vous voulez faire un filtrage supplémentaire ? Par exemple, disons, d'accord, nous voulons obtenir tous les résultats, mais nous voulons seulement voir les résultats où nous avons au moins 15 pistes. Si nous avons essayé d'ajouter ceci dans votre cause et de dire, et si le nombre de pistes est supérieur ou égal à 15, nous allons avoir un problème car l'agrégation n'a pas été effectuée. Et donc nous ne pouvons pas encore le filtrer. Il y a en fait une manière différente que nous pouvons filtrer par les résultats d'agrégation. Et la façon dont nous pouvons le faire est après le groupe par déclaration et avant l'ordre BY, nous pouvons mettre avoir et nous ici nous pouvons mettre l'agrégation que nous voulons filtrer par. Par exemple, nous pouvons dire avoir compté un supérieur ou égal à 15. Et donc cela signifie avoir le nombre de ce résultat d'agrégation ici étant d'au moins 15. Maintenant, l'important est, et exécutons ceci pour voir si le résultat. Donc, vous pouvez voir si nous faisons défiler vers le bas maintenant, nous n'avons pas de résultats qui sont en dessous de 15 et le nombre de pistes. Donc, nous pouvons voir que l'instruction where ici nous
permet de faire le filtrage sur une ligne par des pas de ligne. Nous aurions les moyens de faire l'agrégation dans notre requête. Ensuite, nous devons utiliser la déclaration have. Si nous voulons faire le filtrage par agrégation résultats en même temps que nous faisons l'agrégation elle-même. Et on ne peut pas mettre ça dans la déclaration du gagnant. Nous devons mettre cela dans cette nouvelle déclaration appelée avoir. Maintenant, là encore, nous pouvons également chaîner les filtres. Par exemple, nous pouvons dire avoir un nombre supérieur ou égal à 15 et une durée moyenne de millisecondes supérieure ou égale à 200 mille. Et donc si vous exécutez ceci, et avant que nous avions 13 lignes. Et si nous faisons ça maintenant, maintenant nous avons neuf rangées. Et nous pouvons voir ici dans tous ces cas, le nombre de pistes est d'au moins 15 et la longueur moyenne des chansons va être d'au moins 200 mille millisecondes. Nous pouvons donc encore faire le filtrage supplémentaire en utilisant les mêmes règles que celles que nous avons vues à l'instruction de couche. C' est juste parce que nous faisons l'agrégation, le filtrage pour ces résultats d'agrégation de tout ce que nous faisons dans la requête doit être mis dans cette instruction have spéciale et ne peut pas être mis dans l'instruction where ici.
36. 34JoinsHB: Donc, précédemment, nous avons appris sur la façon de faire des agrégations plus cool, en utilisant
également les instructions de secteur de groupe ainsi que l'utilisation d'avoir pour le filtrage d'agrégation. Mais l'un des problèmes
quelque peu ennuyeux que nous avons vu est que le D optimisé ici est représenté comme un entier plutôt que comme une valeur de nom, par
exemple, ou un titre ici. Et c'est bien sûr, en raison de la nature de la façon dont les bases de données relationnelles sont construites. Et c'est aussi une très bonne pratique parce que cela n'a pas de sens de répéter le même nom. Des centaines ou même des milliers de fois en
fonction de la taille de la table qui obtient dans cette valeur d'ID d'album ici, Il est beaucoup mieux d'avoir un entier qui représente le titre de l'album. De cette façon, si le titre de l'album est modifié, par
exemple, la capitalisation est modifiée ou quelque chose comme ça. Nous n'avons pas à exécuter la mise à jour à travers tout le reste. Mais aussi utiliser des entiers est plus efficace dans l'espace que d'avoir les valeurs de texte intégral ici. Donc, vous verrez cela très souvent que nous avons des tables différentes. Et encore une fois, nous avons également appris cela dans une structure relationnelle. Mais nous aurons des tables différentes pour différentes choses. Par exemple, à, par exemple, chaque album va juste être gardé par lui-même et a un ID spécifique. Chaque artiste ici est référencé par son ID, mais chaque ID représente en fait un artiste spécifique comme nous pouvons le voir ici. Et c'est donc une façon vraiment agréable de diviser les
données pour s' assurer qu'aucune table ne grandit trop ou que nous avons de grandes informations répétitives inutiles dans une table qui peut être rendue plus efficace. Par exemple, si nous avons gardé une trace du nom de l'artiste
et du titre de l'album au lieu de l'ID de l'album. Sur cette affaire, nous n'avons pas la carte d'identité de l'artiste. Mais vous comprenez mon point que si nous gardons une trace du nom plutôt que de l'id, ce n'est pas aussi efficace car il est beaucoup plus efficace de garder une trace des valeurs entières ici parce qu'ils vont être plus petits pris un espace plutôt que en répétant, par exemple, le titre de ceux qui sont sur le point d'aller en Irak, nous vous saluons des centaines ou des milliers de fois selon le nombre d'entrées que nous n'avons pas sont des tableaux différents. Et encore une fois, c'est aussi une bonne pratique parce que si nous voulons changer un titre,
parce que pour une raison quelconque, nous avons remarqué que nous avons fait une faute de frappe ou quelque chose quand nous l'avons mis, plutôt que d'avoir à faire tous ces changements et tous table différente unique qui a cette valeur de titre, nous pouvons simplement la changer dans la, dans ce cas, par exemple, table Album. Et puis n'importe quel album référencé par cet identifiant trouvera juste le bon titre, plutôt que de passer par chaque table de cellules, voir s'il y a un titre là-bas et s'il y a une mise à jour. De cette façon, tout est en quelque sorte une belle structure qui est toujours connectée, mais nous faisons la connexion et une manière beaucoup plus intelligente qui rend tout beaucoup moins sujet aux erreurs et est également plus efficace. Donc, vous doublez là-dedans. Mais bien sûr, nous rencontrons maintenant ces problèmes comme nous le voyons ici, où nous avons l'ID de l'album. Mais vraiment, bien sûr, à ce stade, nous aimerions voir le nom de l'album. Alors, comment peut-on faire ça ? Donc, tout d'abord, ce que je vais faire, c'est que je vais commenter cela parce que j'aimerais revenir à cela plus tard afin que nous puissions implémenter la solution ici. Mais d'abord, je voudrais juste regarder le cas d'utilisation plus simple pour cela. Et ce qu'on va faire, c'est qu'on va écrire une déclaration de jointure où on peut joindre deux tables ensemble. Et nous allons utiliser notre table d'artiste ainsi que la table d'album. Donc on va prendre la table des ABO ici. Et pour chaque album, nous allons nous joindre à la table des artistes. Maintenant, nous savons que la valeur de l'artiste se réfère ici à la clé de l'artiste , de
sorte que nous savons, par exemple, quand nous voyons artistes id et un ici, nous, cela correspond au nom ac-dc. Donc, la façon dont nous pouvons joindre ces tables ensemble est d'utiliser une instruction SQL appelée join. Jetons donc un coup d'oeil à, Let's first write sont juste une sorte d'instructions SQL squelette. Nous allons tout sélectionner. Et nous commencerons juste avec la table de l'album, que nous avons ici. Rappelez-vous dans ce cas, nous n'avons pas besoin des guillemets autour d'elle parce que nous avons fait ce changement là où nous l'avons réellement renommé. Et limitons nos résultats à cinq. Pour l'instant. Allez-y et exécutez ça. Bon, maintenant nous avons notre table d'album ici, mais allons de l'avant et rejoignons les artistes. Donc, pour ce faire, nous allons avoir notre instruction select et définir aussi les colonnes ici que nous allons avoir l'instruction from. Et maintenant, nous allons avoir ensuite une déclaration de jointure. Donc ça va être la table, et ce sera la deuxième table à laquelle nous allons nous joindre. Nous voulions donc nous joindre à cette table, ici, la table d'artiste. Mais maintenant, nous devons spécifier ce que la norme commune, car en ce moment il n'y a aucun moyen de savoir quelle colonne ces tables doivent-elles correspondre à cela ? Bien sûr, vous savez, vous pouvez dire,
Ok, eh bien le titre ici est l'identité de l'artiste. Et si nous allons dans la colonne de l'artiste ici est également appelé Artist ID. Mais rappelez-vous que dans certains cas, nous pouvons simplement appeler cet ID parce que c'est l'ID et c'est implicite qu'il s'agit de l'ID artiste. Mais dans un autre tableau, il peut être appelé l'ID de l'artiste pour rendre plus explicite que cela se réfère à l'ID des artistes parce que nous pouvons avoir d'autres idées, par
exemple, l'ID de l'album. Donc, maintenant, nous devons spécifier ce que ces choses avec ces deux tables doivent être jointes. Et nous le faisons en utilisant la déclaration honnête en disant où. Et maintenant nous disons, d'accord, où l'album oh, eh bien, qui a été complété automatiquement par la prise de données. Mais faisons ça correctement. Où l'album et maintenant dans la colonne de l'album, nous allons trouver l'ID de l'artiste. Donc, où l'ID de l'artiste de l'album, que nous avons ici est égal à. Et maintenant, nous voulons le joindre à la table des artistes. Donc, nous voulons dire où l'ID de l'artiste de l'album est égal à l'ID de l'artiste que nous trouvons à l'intérieur de la table de l'artiste. Maintenant, c'est la déclaration cependant. Nous avons également obtenu la saisie semi-automatique pour acheter à partir de données a grandi. Et si nous regardons réellement nos formats de tableaux, nous pouvons voir ici. Et la raison pour laquelle il sait cela est parce que nous pouvons regarder l'album et que l'ID de l'artiste ici a une clé étrangère qui est liée à l'ID de l'artiste dans la table de l'artiste. Donc c'est juste ici. Donc, nous pouvons voir qu'il y a ces liens de clé étrangère qui sont vraiment
sympas car il spécifie comment ces colonnes sont liées aux différentes tables. Mais nous pouvons en fait utiliser une déclaration honnête ici et nous allons dire, OK. Donc, exécutons ceci pour que nous puissions réellement voir les résultats. Pour que nous puissions voir l'art. Donc nous avons notre identifiant d'album et nous avons notre titre. Celles-ci viennent de la table de l'album ici. Nous avons donc notre album ici, qui a l'ID de l'album et le titre. Mais maintenant, nous avons deux autres colonnes, la carte, l'identité de l'artiste et une autre pièce d'identité d'artiste. Et c'est parce que nous avons deux artistes, l' un de la colonne d'identification de l'album et l'autre de la colonne artiste. Donc, dans ce cas, nous sommes en fait, Il nous montre que c'est l'ID de l'artiste de la colonne de l'album, et ceci est l'ID de l'artiste de la colonne de l'artiste. Et nous pouvons voir ici, bien sûr qu'ils vont correspondre parce que nous avons
rejoint ces tablesà rejoint ces tables la condition que l'ID de l'artiste et la table de l'
album soient égaux à l'ID de l'artiste dans la table de l'artiste. Donc nous pouvons voir ici qui se joint. Maintenant, ces valeurs correspondent ici. Et maintenant, nous avons la colonne de nom, qui vient de la table d'artiste ici. Nous pouvons donc voir que nous avons pris deux bases de données ou deux tables, plutôt, la table de contour et la table d'artiste. Et nous avons juste collé ou nous les avons collés ensemble sur le côté qu'ils sont coincés ensemble où cette colonne d'identité d'artiste est égale, ce que nous pouvons voir ici. Maintenant, à ce stade, il serait vraiment bon de commencer à utiliser des alias de table. Donc, par exemple, nous allons obtenir cette table oui art. Et ici, nous pouvons nous donner, par exemple, ALP. Et donc nous pouvons spécifier maintenant plutôt que de dire album dot artist ID, parce que nous utilisons des alias de table, nous allons dire L dot artist ID. Et là, on va dire l'art. C' est donc la première façon que nous pouvons spécifier, mais aussi nous ne voulons probablement pas sélectionner toutes les colonnes. Nous voulons probablement l'ID de l'album,
mais l'ID de l'album vient de la table de l'album. Il est donc bon de spécifier que nous voulons l'ID de l'album de la table de l'album. Disons que nous voulons le titre de la table de l'album. Vous allez dire à partir de la table de l'album, nous voulons le titre. Et disons que nous voulons une des pièces d'identité d'artiste, mais nous ne voulons pas les deux. Et nous pouvons choisir si nous voulons celui de l'album. Ici, l'ID de l'artiste, ou si nous voulons celui de la table d'artiste, ça ne fait pas de différence parce qu'ils vont être les mêmes parce que nous les avons rejoint. Mais c'est juste agréable d'en choisir un pour que nous n'ayons pas de valeurs en double ici. Et nous voulons aussi le nom de l'artiste lui-même, qui vient de la table de l'artiste. Donc on va partir de la table des artistes, on veut utiliser le nom. Et pour que nous puissions exécuter ça. Et nous pouvons voir maintenant tout est beaucoup plus propre spécifiquement parce que nous n'avons pas de doublons d'artistes, mais il est bon d'utiliser les alias de table de sorte que nous faisons référence aux tables appropriées ici. Et bien sûr, nous n'avons pas besoin d'utiliser un ASUS de table. Nous pouvons également utiliser les noms de table complets, mais il est plus agréable d'utiliser des alias car cela le rend plus court. Mais il est bon de spécifier exactement quelles colonnes vous voulez sélectionner. Parce que beaucoup de fois, surtout lorsque les tables deviennent plus grandes, elles vont être beaucoup de colonnes que vous ne voulez probablement pas utiliser. Et il est donc préférable de simplement spécifier quelles colonnes exactement vous voulez utiliser. Tu ne l'as pas juste pour te joindre. Par exemple, jetons un coup d'oeil. Notre camion transportant ici a un tas de colonnes. Donc, pour nous rejoindre sur une autre table qui est à peu près aussi grande, alors bien sûr, nous allons juste avoir un tas de colonnes. Nous n'allons pas utiliser beaucoup d'entre eux. Donc, vous savez, c'est une bonne pratique de simplement s'en assurer et commençons à fermer certains d'entre eux parce qu'ils prennent aussi beaucoup de place. Il est donc recommandé de sélectionner simplement
les colonnes que vous voulez réellement, sauf si vous voulez les utiliser toutes. Mais même alors c'est bon de savoir que vous ne
voulez pas avoir de colonnes en double ayant l'artiste dont j'ai besoin deux fois, c'est juste un gaspillage d'espace. C' est donc une bonne pratique de spécifier ceux que vous voulez choisir. Donc nous pouvons voir ici, c'est la déclaration que nous avons utilisée pour joindre l'album et la table de l'artiste ensemble. Et cette jointure a été faite sur la colonne où l'ID de l'artiste et la table de l'album sont égaux à l'ID de l'artiste et à la table de l'artiste. Et bien sûr, nous pouvons emporter ou une déclaration de limite ici. Et cela va nous donner la réponse complète pour tous ces cas. Et maintenant quelque chose qui est important à savoir, c'est que ce qui se passe ici est en fait appelé une jointure intérieure. Et nous pouvons spécifier la jointure interne si nous le voulons. Bien que si nous venons d'utiliser l'instruction join elle-même, ce n'est pas le cas, cela va impliquer la jointure interne, mais avec la jointure interne signifie que lorsque l'une de ces valeurs est nulle, il ne va pas se joindre sur eux. Donc, par exemple, si nous avions un cas ici où l'ID artiste est nul, alors cette ligne va être supprimée. Ou s'il y a un ID d'artiste ici, qui n'est pas représenté dans la table d'artiste, alors ces valeurs ne seront pas incluses. Donc, ce qu'une jointure interne signifie est que nous cherchons seulement ou nous obtenons seulement les résultats où cette table ou ces valeurs ont une correspondance ici. Et ces valeurs étaient-elles une correspondance ici ? Maintenant, il y a d'autres joies que nous pouvons faire si nous n'avons pas d'ID d'artiste, par exemple, ici, ou si nous avons un ID d'artiste, mais ce n'est pas représenté ici que nous conservons cette information. Mais dans ce cas, si nous utilisons la jointure interne, ce qui est implicite lorsque nous utilisons la déclaration conjointe, juste la déclaration conjointe simple. Alors on cherche seulement l'intersection de ces deux-là. Nous cherchons seulement où cette valeur et cette valeur, ils existent des deux côtés. Et donc si l'une des valeurs n'existe pas de part et
d'autre, nous n'aurons pas cette pièce. C' est important à savoir car si une valeur est présente quelque part, mais qu'elle n'est pas présente ailleurs, ces lignes vont être supprimées. Alors soyez conscient de cela. C' est ici ce qu'on appelle une jointure intérieure. Bon, maintenant que nous savons comment fonctionne la jointure, Utilisons ça. Tous. Notre déclaration précédente que nous avons commenté, attendez plus tôt maintenant ici. Alors réexécutons ça. Et ce que nous voulons faire, c'est que nous voulons remplacer cette colonne d'ID d'album par le nom de l'album. Alors, comment pouvons-nous modifier notre déclaration ici pour enlever le nom extérieur ? Donc ce qu'on va faire, c'est qu'on va se joindre et qu'on va faire une jointure intérieure. Mais c'est implicite quand on écrit la déclaration commune ici. On va se joindre à cette table de piste ici, la table de l'album, celle-ci. Donc nous allons rejoindre ici, la table de l'album. Je vais utiliser le raccourci ici. Et ici, je vais utiliser, eh bien, juste le TR abrégé. Et je suis en fait spécifier chacune des colonnes maintenant pour m'
assurer qu'il n'y a pas de confusions ou d'erreurs dans le cas où. Par exemple, l'album a également une colonne appelée compositeur, car alors il y aura un conflit de deux. Je choisis un compositeur sur la piste ou sur la table de l'album. Donc maintenant, je vais m'assurer de spécifier chacune des références
de colonne que je dois m'
assurer qu'il n'y a pas de confusion ou d'erreurs qui se produisent. Donc tous ces cas quand on l'utilise sur la table de piste, parce que maintenant on apporte la table de l'album. Donc, sur la table du camion, nous allons faire une jointure interne avec la table de l'album. Et nous allons rejoindre sur où le,
en utilisant le raccourci pour attirer la table, où l'ID de l'album est égal à V ID de l'album de la table. Et maintenant, plutôt que de sélectionner l'ID de l'album ici, je veux sélectionner étendre le titre de l'album à partir de la table de l'album. Donc, si nous lançons ça et que nous avons toujours notre référence d'album ici. Donc, dans ce cas, nous pouvons réellement faire le regroupement par titre de
l'album parce que nous effectuons la jointure et ensuite nous effectuerons l'opération d'agrégation. Vous pouvez donc voir ici d'abord que nous effectuons la jointure, puis nous effectuons l'opération d'agrégation de groupement. Donc, plutôt que de nous joindre à l'ID de l'album,
MAINTENANT, nous allons nous joindre au titre de l'album. Ça va nous donner le même résultat, bien sûr, parce que la carte d'identité fait référence à un titre. Laissons ça une fois de plus. Et maintenant, nous pouvons voir que notre ID a été remplacé par le titre qui vient de la table de l'album ici. Et nous avons eu cela parce que chaque raisonnement, la table des pistes, chaque ID d'album ici, nous avons rejoint l'ID de l'album ici, et nous avons mis à jour notre déclaration de sélection pour extraire à la place le titre de la table de l'album, où notre titre et notre table d'album ont été réunis sur. Donc, nous pouvons nous rappeler ici que nous avons rejoint nos deux tables aussi sur les colonnes d'identification de l'album. Dans ce cas, l'ID de l'album a été appelé et mon D dans les deux cas, et dans certains cas, par exemple, dans la colonne de l'album, il serait logique de simplement appeler ce DID car il serait implicitement implicite que l'ID représenterait l'ID de l'album. Donc, au cas où je dirais juste une pièce d'identité ici. Et puis nous ferions simplement référence à la colonne ID de la table de l'album. Dans ce cas, ce n'est pas le cas. Mais je dis juste que ces deux-là ne doivent pas toujours être égaux. Dans ce cas, ils se trouvent être égaux, mais il y a aussi beaucoup de cas où ils ne seront pas égaux parce que la clé primaire serait simplement appelée ID, plutôt que d'avoir le nom de la table ou quelque chose qui spécifie également quel ID il est exactement. Donc, nous pouvons voir les jointures sont très utiles raison de la façon dont les bases de données relationnelles sont construites, ce qui est vraiment utile et efficace parce qu'il nous
permet de séparer les informations et juste garder une trace de différents les choses séparément pour s'assurer que tout n' affecte pas tout le reste que nos entrepôts sont efficaces. Et puis quand nous faisons des mises à jour, ces mises à jour seulement pour, euh, être appliquées en un seul endroit. Et puis quand nous utilisons des jointures qui
se propagent essentiellement partout parce que nous utilisons des identifiants partout ailleurs. Donc, beaucoup de ceci est une très bonne pratique qui conduit à de bonnes performances, bon stockage, et conduit également à une mise à jour beaucoup plus facile. Ensuite, nous pouvons utiliser les déclarations conjointes parce que nous avons toutes ces relations entre nos différentes tables pour ensuite remplir les informations appropriées. Par exemple, remplacer l'ID de l'album ici par le titre de l'album. Et nous pouvons voir ici aucune de nos autres déclarations vraiment changé sauf parce que nous ne sommes plus en train d'utiliser V ou de retirer l'ID de l'album. Nous devons plutôt remplacer l'agrégation, le titre de
l'album au lieu de l'ID de l'album, car l'ID de l'album n'est plus dans l'instruction select ici. Et puis l'autre chose que nous avons fait comme ajouter les alias pour
notre table pour s'assurer qu'il n'y a pas de confusion. Par exemple, lorsque nous avons des noms de colonnes en double pour nous assurer que nous faisons référence à la colonne correcte d'une table spécifique. Donc, par exemple, ici se référant à la colonne compositeur de la table truck, car il se peut que la colonne compositeur puisse également exister dans la table de l'album. Donc, pour nous assurer que nous n'obtenons pas cela, nous spécifions quelle table, mais je veux choisir juste au cas où vous êtes confus par ce qui vient de se passer, si vous double-cliquez dessus, enlève ce volet de navigation sur la gauche double-cliquez dessus et il le ramène juste comme une note de côté. Mais oui, comme vous pouvez le voir, les jointures sont vraiment sympa car cela nous permet de
regrouper toutes ces informations qui sont délibérément divisées en raison de la structure des bases de données relationnelles.
37. 35LeftRightFullJoinsHB: Bon, donc maintenant nous avons appris une jointure, spécifiquement des jointures internes où nous regardons l'intersection entre deux tables. Mais dans ce cas, nous ne sommes que limités à l'intersection. Et il peut y avoir des cas où nous avons des données sur quelque part et il peut ne pas y avoir de valeur correspondante ailleurs. Par exemple, jetons un coup d'oeil à cette table de lignes de facture. La ligne de facture contient juste des informations d'achat sur qui ou ce qui a été acheté, quelle facture était, quelle piste a été achetée au prix, ainsi que la quantité achetée. Et nous pouvons voir que nous avons une référence d'identification de piste ici. Et si nous regardons cela,
bien que vous savez probablement déjà où le nom, nous pouvons voir ici, l'ID du camion est une référence de clé étrangère à l'ID du camion dans la table du camion. Donc, si nous ouvrons la table des pistes, peut voir ici nous avons les différents ID de piste. Alors comptons le nombre de pistes que nous avons dans la table des camions en premier. Alors allons de l'avant et sélectionnons et nous allons juste compter un de notre table
de camion. Et nous ne ferons rien d'autre. Et nous pouvons voir ici que nous avons 3500 et trois rangées différentes. Et puisque chaque ligne a un ID de piste unique parce que l'ID de camion est la clé primaire, nous pouvons également déduire que nous avons 3500 et trois pistes uniques. Mais juste parce que nous avons autant de pistes, cela ne veut pas dire que chaque piste qui a été achetée,
peut-être que c'était peut-être ce n'était pas le cas. Allons le découvrir. Donc, si nous regardons la ligne de facture, comment pouvons-nous compter combien de pistes différentes ont été achetées ? Actuellement, nous avons nos méthodes d'agrégation, mais nous n'avons pas encore d'outil spécifique pour comprendre exactement combien de pistes uniques ont été achetées ici. Puisque certaines pistes peuvent être achetées plus d'une fois, puisque différentes personnes peuvent acheter la même piste. Si souvent on découvre ça. Ce qu'on peut faire, c'est apporter une légère modification à notre déclaration des comptes ici, qui est à l'intérieur. Vous pouvez mettre le mot-clé distinct, qui va chercher des occurrences distinctes. Mais dans ce cas, nous ne sommes plus autorisés à utiliser le numéro 1. Vous devez faire une référence spécifique à une colonne. Nous allons donc référencer la colonne ID de piste à l'intérieur de la ligne de facture. Nous allons donc faire référence ici à la piste du D et nous allons mettre à jour notre table de la piste à la table de ligne de facture. Alors couvrons cette déclaration. En temps de guerre, nous faisons l'agrégation des dénombrements. Mais au lieu de simplement compter toutes les occurrences, nous voulons connaître le nombre d'occurrences uniques et l'ID de piste. Donc, nous voulons savoir combien d'ID de piste différents et présents à l'intérieur de cette colonne d'ID de piste. Et c'est ce que le distinct nous permet de faire à l'intérieur ici, nous
permet de compter l'occurrence unique. Cela nous permet de compter des occurrences distinctes d'éléments distincts à l'intérieur ici. Encore une fois, il est important que nous référentions réellement la colonne où nous voulons trouver le nombre d'occurrences uniques à l'intérieur. Donc, si nous exécutons ceci, nous pouvons voir dans la table de ligne de facture et dans la colonne ID camion, nous avons cent, dix cent neuf cent quatre-vingts quatre pistes différentes ou plutôt uniques. Cela ne veut pas dire que chaque camion ne se présente qu' une fois qu'il est possible qu'il soit apparu plus d'une fois. Ce n'est pas l'information que nous essayons d'obtenir. Nous savons juste que 1984 ID de piste uniques apparaissent dans cette colonne d'ID de camion à l'intérieur de la table de ligne de facture. Alors, qu'est-ce que cela signifie et pourquoi est-ce important ? Eh bien, si nous voulons peut-être rejoindre notre piste et notre table de ligne de facture, cela signifie
que certaines de nos pistes en fait plus
d'environ 1000 ou même plus de 1500 pistes n'ont pas de factures pour boucle, ce qui signifie que les données ne seront pas utilisées parce que nous regardons l'intersection. Mais parfois on ne veut pas la perdre. Parfois, s'il n'y a pas de facture, nous voulons juste la garder comme vous le savez, nous voulons la garder là, mais nous voulons juste
avoir un mot à dire qu'il n'y a pas de données pour celle-ci. Et donc nous ne pouvons pas le faire avec une jointure interne parce que la jointure interne recherche l'intersection. Alors écrivons une requête où nous prenons notre table de piste ici. Et à chaque piste, nous joignons également essentiellement les informations que nous avons ici à partir de notre tableau de ligne de facture. Maintenant, pour chaque piste
, nous allons avoir au moins une facture. Maintenant, nous pouvons avoir plusieurs factures, ce qui signifie que nous allons obtenir quelques lignes en double où les informations sur la piste elle-même comme un doublon. Mais alors les informations sur la facture vont être séparées. Donc pour faire ça, ou on va le faire, on va dire « sélectionner ». Et commençons simplement par sélectionner tout de la table des pistes. Sauf si on lui donne un TR abrégé. Et nous allons maintenant faire une jointure à gauche. Et nous allons le rejoindre sur la table des lignes de facture. Et nous allons juste donner ce raccourci aussi I L. Et puis nous allons rejoindre sur où l'identification du camion du camion. Et nous pouvons déjà voir que le groupe de données
nous le suggère à cause de la référence de clé étrangère. Mais où l'ID de camion de la piste est égal à l'ID de camion de la table de ligne de facture. Donc encore une fois, nous voulons correspondre où cet identifiant camion est égal à celui que nous avons ici. Et si nous avons plus d'une occurrence, par exemple, pour notre première piste ici, alors nous allons faire dupliquer les données de la table des camions. Donc, nous allons avoir deux lignes ici, mais les données de la facture qui va être attachée à
elle va être une ligne pour pratiquement chaque facture, chaque facture séparée que nous avons pour elle. Donc, nous n'allons pas avoir des lignes pleines en double. Ce pourrait être les parties de celui-ci, par exemple, de notre table de suivi ici, peuvent être dupliquées, mais alors les factures correspondantes s'il y a plus d'une facture, par exemple, s'il y a trois factures pour la première fois ici, pour ceux qui sont sur le point de faire du rock, nous vous saluons et nous allons avoir trois rangées pour cela. Suivi, l'information va rester la même, mais chaque ligne va avoir des informations sur une facture distincte. Mais tout cela sera disponible pour nous pour chaque ligne, pour chaque enregistrement que nous avons dans notre table de jointure maintenant. Alors allons de l'avant et lançons simplement ceci pour voir le résultat. Et comme nous pouvons le voir ici, nous avons maintenant à nouveau les informations quand il y a colonnes en
double sur quelle table provient la colonne. On a des informations de la table de suivi. Et puis, si nous faisons défiler vers la droite, nous avons également les informations de la table de ligne de facture, que nous pouvons voir ici. Et donc, ouais, ça va être nos tables qui sont maintenant réunies ensemble. Mais l'important est, et regardons le nombre d' idées
de piste de notre colonne de piste qui apparaissent ici. Donc, nous allons compter le nombre distinct, et nous allons nous concentrer sur l'ID de camion de la colonne de piste, puisque toutes les pistes n'apparaissent pas dans notre tableau de lignes de facture ici, mais toutes les pistes sont gardées dans notre tableau de suivi ici. Examinons donc le nombre unique d'ID de piste que nous avons dans cette table de jointure, concentrant sur l'ID de camion de colonne qui provient de la table de piste. Donc en cours d'exécution, nous pouvons voir que nous avons 3500 et trois pistes uniques, qui est exactement ce que nous attendons. Mais pour ces pistes, pour toutes, nous avons en fait des données de facturation. Donc, nous allons juste tout sélectionner à nouveau ici. Mais concentrons-nous sur la recherche des cas où nous n'
avons pas de données de facturation pour voir à quoi elles ressemblent. Donc nous allons dire où l'ID du camion de ligne de facture. Et maintenant, dans les cas où nous n'avons pas de données, ces valeurs vont être nulles. Nous allons donc chercher où l'une des colonnes de notre ligne de facture est nulle. On peut utiliser la carte d'identité du camion. Nous pouvons également utiliser n'importe quelle autre colonne de la ligne de facture. Parce que si nous avons une piste qui
n'a pas de données correspondantes et la table sur laquelle nous la joignons, alors les lignes résultantes pour cette articulation vont juste être nulles. Donc si nous faisons ça, vous pouvez voir ici nous avons, par
exemple, le camion ID 7. Et si nous regardons, nous n'avons pas de données de facture qui correspondent à cela. Et donc c'est ce que fait notre jointure gauche avec une jointure gauche, c'
est qu'elle prend toute cette colonne et prend la première, désolé, elle prend la première table entière, cette table entière ici. Et il le rejoint sur, ou se joint sur une autre table et joint à cette condition. Mais s'il n'y a pas d'instance correspondante dans notre deuxième table, alors nous allons toujours garder les informations de cette première table ou à partir de là une table de gauche est une sorte de ce que vous pouvez en penser. Mais parce que nous n'avons pas d'informations correspondantes de
l'autre table, les valeurs que nous avons ici vont être nulles car il n'y a pas d'informations correspondantes à ajouter à cela. Alors, en quoi cela diffère-t-il de la jointure intérieure que nous avions auparavant ? Eh bien, si on enlève la gauche ici, et si on recommence, on verra ici que nos résultats ne seront rien. n'y a pas de puits, pas de ligne où il y a une valeur nulle à l'intérieur de cette ligne de facture. Et c'est parce que quand on fait une jointure intérieure, on regarde l'intersection. Alors que si nous faisons une jointure gauche, nous gardons toutes les informations de la première table. Et si les informations de la deuxième table existent, nous allons l'ajouter sur. Mais dans les cas où ces informations n'existent pas, par exemple, dans les cas où le tractus n'a pas de facture et la table de ligne de facture. Ensuite, parce que nous avons toujours les colonnes et la table de jointure résultante, ces vallées ici vont juste être nulles parce qu'il n'y a rien à cela. Et donc nous pouvons voir que c'est ce que fait la jointure gauche, c'est que nous ne jetons pas les lignes qui n'ont pas de données correspondantes dans l'autre table. Ce qui peut parfois être bon. Parfois, ce n'est pas non plus bon parce que
cela signifie également que vos tables résultantes vont être beaucoup plus grandes. Parce que s'il n'y a pas, il n'y a pas de données correspondantes, alors dans l'intersection, cela serait
jeté et la table résultante serait plus petite, alors que maintenant nous nous y tenons. Donc, selon ce dont vous avez besoin, si vous voulez toujours conserver des informations qui peuvent ne pas avoir d'informations correspondantes dans l'autre table, vous voulez utiliser une jointure gauche. Une autre alternative est une jointure droite, que nous verrons dans une seconde, ou une jointure complète ou une jointure externe complète. Mais si vous voulez seulement vous concentrer sur l'intersection, alors vous voulez vous assurer que vous utilisez une jointure interne, que vous pouvez également raccourcir en ayant juste la jointure ici. J' ai donc mentionné deux autres types de jointures. Donc, nous avons la jointure gauche, qui va fonctionner tout. Donc, nous avons la gauche rejoindre. Maintenant, la jointure gauche se concentre à nouveau sur la conservation de chaque valeur unique à partir ici et la jointure sur les données de cette table ici. Et dans les cas où il n'y a pas de correspondance à partir de la deuxième table, nous gardons toujours les données de
la première table que les valeurs correspondantes de la deuxième table, nous allons juste être non. Maintenant, il y a aussi quelque chose qu'on appelle une jointure droite et une jointure droite. La différence est que plutôt que d'avoir cette table sorte de garder toute la forme la base et de garder les valeurs nulles. Par exemple, je vais avoir cette table. Et donc la jointure droite et la jointure gauche ou juste une question de perspective, parce qu'une jointure droite, ce qu'est une jointure droite, c'est fondamentalement une jointure gauche. Mais on a retourné l'ordre de la table comme ça. C' est ce qu'est une jointure droite. Et donc, vous savez, il est plus facile de toujours aller avec une jointure gauche et juste avoir votre ordre de table en conséquence. Et que vous utilisez toujours la première table comme base à laquelle vous pouvez vous joindre. Parce que sur une jointure gauche, s'il y a quelques valeurs ici, par
exemple, dans la colonne de piste. Et si nous exécutons ceci, nous pouvons voir qu'il
n'y a aucun cas dans notre ligne de facture où nous avons un identifiant de camion qui est présent dans la ligne de facture, qui n'est pas présent dans la table de suivi. n'y a pas d'instances. Donc, si nous faisons une jointure gauche sur la ligne de facture, alors ce résultat ici sera nul. Mais si nous avons fait une bonne jointure maintenant, en utilisant notre syntaxe actuelle que nous allons obtenir le résultat que nous avons avant. Parce que maintenant nous gardons également les informations de la table des camions et il y aura pistes qui sont gardées trace d'une vieille table des camions qui
n'ont pas de facture correspondante dans la table des lignes de facture. Donc on peut voir une jonction gauche et droite ou juste, ils sont fondamentalement la même chose. C' est juste l'ordre dans lequel nous mentionnons ces tables est différent. Ainsi, vous pouvez utiliser une jointure gauche au lieu d'une jointure droite et simplement retourner l'ordre des tables. Et c'est généralement une meilleure façon de le
faire juste pour vous assurer que vous gardez une façon de penser cohérente. Mais bien sûr, vous avez toujours la possibilité de le faire. Maintenant, il y a aussi un autre type de jointure, ce
qui est le cas si nous voulons garder toutes les informations des deux tables ? Que se passe-t-il si nous avons des données et notre table de ligne de facture qui n'a pas de valeurs correspondantes dans la table de suivi. Et nous avons certaines données dans la table de suivi qui n'ont pas valeurs
correspondantes dans la table de ligne de facture. Et nous voulons garder tout ça. Et dans les cas où nous avons des données sur la table de ligne de facture, mais pas dans la piste. Nous voulons que les valeurs du, pour les colonnes qui proviennent de la table de pistes soient nulles. Et dans les cas où nous avons des informations sur la piste, mais pas sur la ligne de facture ou pas de valeur correspondante dans la ligne de facture. Nous voulons que les valeurs dans les colonnes qui correspondent à la ligne de facture soient non et que les valeurs pour le camion soient
toujours là afin que nous ayons l'intersection ainsi que les informations de chaque bande. Et donc cela est appelé une jointure complète, ou c'est aussi appelé une jointure externe complète. Là, la même chose. Donc, encore une fois, quel groupe ce que cela fait est que vous regardez l'intersection ainsi que toutes les valeurs des deux tables qui n'ont pas de valeurs correspondantes dans l'autre. Alors qu'avec la jointure gauche, vous regardez l'intersection ainsi que toutes nos valeurs dans la première table qui n'apparaissent pas dans la deuxième table. Une jointure de droite, vous regardez l'intersection ainsi que toutes
les valeurs de la deuxième table qui n'apparaissent pas dans la première table. Désolé, oui, ce sont les différents types de jointures qui sont disponibles pour nous. Rappelez-vous, je sais, si vous augmentez ou joignez des tailles essentiellement allant de l'intérieur à la gauche ou à la droite à une jointure externe complète. Vous allez conserver plus de données et vous
conservez également les données qui peuvent ne pas être appariées dans l'autre table. Mais cela signifie également que vos tables résultantes seront plus grandes. Maintenant, généralement lorsque nous faisons des jointures, les tailles de nos tables ne vont qu'augmenter parce que nous pouvons avoir, par exemple, une seule instance dans la table de suivi peut avoir plusieurs factures correspondantes dans la table de lumière des factures. Donc, si nous avons 100 titres et que chaque piste a trois factures, notre table va grandir parce que nous devons garder une trace de chacune de ces voix intérieures aussi. Alors pense juste à ça. Même si vous commencez par une petite table, vos tailles de table peuvent augmenter parce que vous recherchez toutes ces intersections. Donc encore une fois, vous savez, utilisez-le en fonction de vos besoins, mais n'utilisez pas seulement les jointures
externes à gauche ou à droite ou complètes si vous n'allez pas utiliser les données parce que la table correspondante qui va être grande. Et il est préférable de ne regarder l'intersection si vous êtes réellement intéressé uniquement par tous les cas où les colonnes qui proviennent de chaque table ou les deux NOT null. Fondamentalement, vous voulez vous assurer que vous avez toutes les informations de la table de suivi qui contient des informations correspondantes dans la table de ligne de facture. Donc, seulement se concentrer sur l'intersection et ces cas
assurez-vous simplement d'utiliser la jointure pour réduire la taille de votre table, ce qui va être plus efficace. Et cela va aussi conduire à de meilleures performances. Mais un autre sur la dernière, si vous avez des instances où vous voulez vous assurer que vous pouvez observer cette information, même s'il n'y a peut-être pas de valeurs correspondantes dans l'autre table, vous avez toujours la possibilité d'utiliser la , ainsi que les jointures complètes sont des jointures externes complètes comme leur nom complet est appelé.
38. 36SelfJoinsHB: Maintenant, nous avons vu que différents types de jointures, jointures externes gauches
internes, où nous pouvons joindre les informations d' une table à l'information que nous avons dans une autre table. Mais en fait, il n'y a rien dans les déclarations conjointes qui disent que vous ne pouvez pas joindre une table sur elle-même. En fait, on peut le faire. Nous pouvons faire une auto-jointure où nous prenons les informations d'une table et nous les rejoignons sur elle-même. Donc c'est ce que nous allons regarder maintenant. Et nous allons également examiner comment nous pouvons utiliser, ou plutôt comment nous pouvons nous joindre à plusieurs conditions. Depuis avant, on était toujours juste en correspondance. Par exemple, l'ID du camion et la ligne de facture doivent être égaux à l'ID du camion dans la table du camion. Mais nous pouvons également utiliser plusieurs conditions comme nous l'avons fait dans le filtrage par exemple. Alors jetons un coup d'oeil à ça. d'abord, il suffit de sélectionner tout à partir de notre tableau de ligne de facture, nous
donne l'IL abrégé. Et puis nous allons nous joindre à nouveau sur la facture, sur la table des lignes de facture. Et donnons juste à ceci une ILA abrégée, juste une ligne de facture et puis un pour conditionnel. Et donc nous allons nous joindre, tout d'abord, nous voulons nous joindre à l'endroit où la ligne de facture et l'ID de facture sont les mêmes. Donc, dans ce cas, je veux chercher une facture et je veux voir ce que d'autres achats ou peut-être fait dans cette facture. Et donc nous verrons pourquoi exactement. Nous le ferons plus tard dans cette vidéo. Donc, nous allons simplement nous joindre à l'endroit où les ID de facture ici sont les mêmes. Nous pouvons donc voir que nous pouvons avoir différents ID de ligne de facture, mais tous ces différents articles font partie dans ce cas de la même facture. Ainsi, par exemple, dans cette facture, la personne a acheté deux pistes différentes. Et donc nous pouvons voir que nous avons deux pistes différentes représentées ici. Donc, nous allons joindre à l'endroit où la ligne de facture, l'ID de facture est égal à l'ID de facture de notre deuxième table de ligne de facture ici, ou à la même table de ligne de facture. Mais ajoutons aussi une autre condition ici où nous disons que nous voulons l'ID de piste soit plus grand que l'ID de camion dans notre première table. De cette façon, nous pouvons juste nous assurer que nous n'avons pas un tas de matchs croisés, mais que nous avons au moins une sorte de commande. Encore une fois, nous verrons l'application ici dans une seconde. Donc je vais juste prendre notre numéro de camion de la ligne de facturation et nous voulons avoir ceci. Nous voulons que l'ID du camion du conte traditionnel soit
supérieur à l'ID du camion de la table initiale. Maintenant, la commande ici n'a pas vraiment d'importance parce que tout est un peu symétrique. Mais cela aide juste à visualiser cela dans votre tête. Le second est une sorte de celui que vous voulez voir comme référence. Et celui-là, vous pouvez penser à nous, la base. Et vous pouvez voir ici la simplicité d'ajouter des
conditions supplémentaires à nos déclarations de jointure est juste en mettant fin ici. Donc nous disons à cette condition, et ensuite nous pouvons simplement utiliser les mains pour enchaîner sur des conditions supplémentaires. Nous pouvons aussi utiliser une guerre est si nous voulons. Donc, tout comme nous l'avons vu dans les cas où, le même genre de logique s'applique si vous voulez faire plus de logique conditionnelle ici pour savoir comment nous voulons exactement relier ces tables ensemble. Donc encore une fois, ce sera fondamentalement le même que ce que nous avons vu dans le filtre dans les cas. Sauf maintenant, nous le faisons sur la
déclaration sur qui fait référence à la déclaration conjointe que nous avons ci-dessus. Alors mettons notre point-virgule ici et lançons ça. Donc les résultats que nous obtenons de cela, nous pouvons voir ici nous avons, nous avons toutes les mêmes colonnes, une pour chaque table. Nous avons l'ID de ligne inverse
des premières tables ici et toutes les autres valeurs correspondantes. Et puis nous avons les mêmes colonnes de la deuxième table, la ligne de facture a, comme nous l'appelons. Et encore ici du MOS sur l'ID, l'ID de la facture, l'ID du camion, et le prix unitaire. Mais nous pouvons aussi voir que nous avons ici l'ID du camion de la deuxième table que nous avons rejoint sur ces quatre. Et l'ID de camion du premier est de,
selon notre deuxième condition ici, l'idée de camion de la deuxième table doit être plus grande que l'ID de camion de la première table. Alors pourquoi voudrait-on faire ça ? À quoi peut-on utiliser cela ? Eh bien, il y a certains moments où ces noms d'informations seront divulgués. Eh bien, par exemple, disons que nous voulons
comprendre quelles pistes sont souvent achetées ensemble ou si quelqu'un achète un camion, quelles sont la craie peut-être aussi comme certains. Ce que nous pouvons faire est de donner certains de ces noms de table, un alias afin que nous puissions mieux le référencer. Et nous n'avons pas besoin de toutes les données ici. Donc ce que nous voulions sélectionner comme nous voulons prendre l'ID de camion de notre table de ligne de facture. Le premier ici, nous pouvons appeler ça comme piste de base, peut-être le genre de piste de base qui est acheté. Et nous voulons aussi les informations d'identification du camion de la deuxième table. Et cela peut être le camion supplémentaire, et nous avons également besoin du mot clé comme ici. Donc, si nous regardons cela, maintenant, nous avons ce camion, il a été acheté et cette piste a également été acheté. Nous avons cette piste a été acheté et ce camion a également été acheté avec elle. Et ce camion a été acheté et cette piste a également été achetée avec elle. Alors maintenant, nous avons des informations sur. Une piste qui était Bob, ainsi qu'une autre piste qui a été achetée avec la même piste. Donc, disons que nous voulons savoir quelles pistes sont souvent achetées avec le camion ID 6. Donc, si on va à la table de piste ici, juste faire cette recherche manuellement. D' accord. Truck ID 6 correspond à vous mettre le doigt, ce camion. Donc, disons que nous voulons trouver où nous voulons savoir si quelqu'un achète cette piste, quelles sont les autres pistes qu'il aimerait ? Ou plus généralement, quelles sont les autres pistes qui ont été achetés dans le même type de facture parce que si quelqu'un achète ce camion et ils achètent également un autre camion, est probable qu'ils vont être pas comme l'autre pistes vers. Donc, si quelqu'un veut acheter ce camion, peut-être comme une première chose à laquelle nous pouvons penser est ce que d'autres camions aux gens qui ont déjà acheté cette piste, quels autres camions qu'ils achètent également. Parce que peut-être quelqu'un qui achète ce camion peut aussi être intéressé par les choses que d'autres personnes ont achetées. Et donc nous pouvons utiliser ce résultat ici pour obtenir très rapidement cette information en utilisant une déclaration groupe par déclaration. Parce que nous pouvons dire, d'accord, allons grouper par notre piste de basse. Et nous voulons également regrouper par la suite sont piste supplémentaire. Et maintenant, nous voulons également utiliser une agrégation et nous voulons compter le nombre d'occurrences As. Et on peut appeler ça des achats appariés peut-être. Et puis nous allons tout commander par les achats appariés dans l'ordre décroissant pour juste obtenir une sortie de table ici d'un que ce camion a été acheté. Et quand un autre camion a été acheté avec lui, combien de fois ces pistes ont été achetées ensemble ? Alors allons de l'avant et lançons ça. Et nous pouvons voir ici, par exemple, quand le camion 1412 a été acheté qu'ils étaient deux fois où le camion 1424 a également été acheté avec lui. Et nous pouvons voir dans ce cas le genre d'achats appariés sont, sont assez faibles. Mais c'est aussi une sorte de limitation du nombre de pistes disponibles, ainsi que du nombre de factures que nous avons dans nos données et à mesure que le nombre de factures dans notre tableau de lignes de factures augmente ici. Cela signifie que nous aurons plus d'achats, plus d'informations sur les achats, et nous obtiendrons plus d'informations sur les pistes souvent achetées ensemble. Nous pouvons donc nous attendre à ce que ces chiffres augmentent également. Bien sûr, nous pouvons également trier dans l'autre ordre pour voir, ok, eh bien, puisque notre valeur maximale est deux, la seule autre option que nous avons est d'avoir une valeur de un. Mais vous pouvez voir l'approche que nous pouvons adopter avec ceci est que nous pouvons joindre une table sur elle-même. Et généralement, nous voulons utiliser des conditions supplémentaires sur les emplois. Maintenant, nous n'avons pas seulement besoin d'utiliser des conditions supplémentaires sur les auto-jointures. Nous avons également bien sûr la possibilité d'utiliser des conditions
supplémentaires lorsque nous faisons d'autres types de jointures. C' est juste lorsque nous faisons des auto-jointures, nous voulons probablement utiliser des conditions supplémentaires ou simplement faire un filtrage supplémentaire. Parce que si vous joignez toutes les informations sur la table sur elle-même, encore une fois, votre taille de table va augmenter beaucoup. Donc, pour vous assurer que vous réduisez cela et ne prenez vraiment que les informations dont vous avez besoin. Vous voulez probablement mettre dans des conditions supplémentaires à cette déclaration ici à propos de la jointure qui se passe ci-dessus. Et donc, dans ce cas, par exemple, nous avons pu utiliser l'auto-jointure pour obtenir rapidement au moins quelques informations superficielles sur, vous savez, si un camion a été acheté, quelles autres pistes ont également été achetées et à quelle fréquence ces pistes ont -elles été achetées ensemble ?
39. 37UnionsHB: Nous avons donc vu des jointures maintenant, mais il y a aussi d'autres cas où nous pouvons vouloir joindre des informations sur les tables ensemble, mais nous ne voulons pas les joindre horizontalement, mais plutôt nous voulons les empiler verticalement. Et ceux-ci peuvent apparaître, par exemple, si vous avez plusieurs tables qui gardent une trace de la même chose, mais l'information est divisée sur plusieurs tables juste pour empêcher une table individuelle de devenir peut-être trop grande. Ou vous avez des tables différentes, chacune représentant des données d'un jour individuel. Et vous voulez joindre toutes ces informations ensemble dans une seule table afin que vous puissiez réellement exécuter une requête sur la table complète. Alors, comment peux-tu faire ça ? Eh bien, nous allons tout d'abord créer nos deux sous-ensembles de tables pour que nous puissions les relier ensemble. Et nous allons utiliser l'instruction create table. Et nous allons appeler cette piste de table première partie. Et nous allons créer ceci à la suite de la requête suivante. Nous allons tout sélectionner dans la table des pistes, mais seulement lorsque l'ID du camion est inférieur ou égal à 2000. Mettons un point-virgule ici pour une bonne pratique. Et allons de l'avant et exécutons ceci et jetons un coup d'oeil à notre base de données maintenant. Donc, en entrant dans nos schémas dans une table ici. Donc nous avons notre seule table, ce camion, une, qui contient toutes les informations de notre traçable, mais seulement les deux premiers mille camions. Et puis nous allons créer un deuxième camion de table Partie 2, où toutes les informations et où le camion ID MOOC de la table de camion est supérieur à 2000. Donc, nous sommes en train de diviser notre table de piste ici, dont nous nous souvenons d'un peu plus tôt, contient environ 3 500 rangées en deux petites tables, camion partie 1 et camion garé aussi. Comme nous pouvons le voir, si nous ouvrons celui-ci ici, nous pouvons voir que nous commençons le camion ID 2001. Alors, comment pouvons-nous joindre ces informations ensemble ? Parce que nous voulons peut-être utiliser le résultat de toutes nos pistes parce que nous en avons besoin pour quelque chose. Peut-être, vous savez, si nous voulons faire une jointure sur toutes nos craies, nous devons d'abord être en mesure de joindre ou différentes tables ensemble afin que nous ayons réellement toutes les informations sur toutes les discussions que nous avons, plutôt que d'utiliser une table plus petite qui ne contient qu'un sous-ensemble de toutes les données que nous avons. Donc, pour ce faire, nous pouvons juste, tout d'abord, juste un peu de squelette de l'écrivain la déclaration select ici, nous allons tout sélectionner. Commençons simplement avec le camion Partie 1 et ici nous
voulons maintenant ajouter sur les informations du camion Partie 2. Donc, pour ce faire, nous allons utiliser une déclaration syndicale ici. Et puis nous allons avoir une autre déclaration select où nous allons à nouveau tout sélectionner. Maintenant, nous allons dire tout sélectionner de la partie 2 de la piste. Donc, si nous exécutons ça, nous allons maintenant tout faire et mettre un point-virgule ici aussi pour une bonne pratique. Donc nous allons avoir toutes nos informations sur les deux pistes. Nous sélectionnons tout de la partie 1 du camion. Nous sélectionnons tout dans la partie 2 de la piste. Et cette déclaration syndicale ici signifie que cette information, ou que ces deux résultats vont être réunis verticalement empilés. Donc, plutôt que d'avoir le genre de jointures
horizontales que nous avons vues lorsque nous utilisons les déclarations conjointes. Et au lieu de cela, le syndicat est, nous allons utiliser les résultats d'ici. Et nous allons juste ajouter au fond aussi les résultats que nous avons d'ici. Et donc de cette façon, nous pouvons utiliser les instructions de l'union pour ensuite regrouper plusieurs tables. Et nous pouvons même prolonger cela. Dans ce cas, nous n'avons que deux tables, mais faisons semblant d'avoir une autre table pour pouvoir faire un autre syndicat. Et disons que nous voulons tout sélectionner à nouveau de la piste Luke partie 2. Et on peut recommencer ça. Et nous pouvons voir qu'il fonctionne toujours. Donc, si nous avions plusieurs tables ici, nous pourrions simplement faire plusieurs déclarations syndicales où nous
sélectionnons les informations que nous voulons dans la table appropriée. Et puis en utilisant la déclaration d'union ici pour en quelque sorte le coller, au-dessus de l'autre afin que le résultat final, va être la table finale que nous voulons réellement qui contient toutes les données type de jointes ensemble. Encore une fois, dans les cas où dans vos données et peut-être divisé sur plusieurs tables différentes, vous pouvez utiliser les instructions d'union pour joindre ces informations à partir de toutes les tables ensemble afin que vous ayez
tout en un seul endroit de sorte que lorsque vous êtes exécutant votre requête, vous pouvez l'exécuter sur toutes les tables. Sont toutes les données des tables séparées jointes ensemble, empilées verticalement les unes sur les autres. Plutôt que d'avoir à interroger chaque sous-table individuellement, puis essayer de joindre les résultats plus tard. Maintenant, si nous voulons nous débarrasser des deux tables à nouveau, rappelez-vous tout ce que nous avons à faire, vous avez juste à dire la table de chute. Et nous allons laisser tomber notre camion partie 1 et faire ça. Et puis nous allons aussi abandonner notre tronc partie deux et exécuter cette nouvelle fois maintenant avoir une sorte de base de données nettoyée parce que nous n'avons pas besoin de diviser notre table de pistes en deux pistes distinctes. Nous pouvons donc les utiliser ou les utiliser comme exemple de l'Union. Mais alors c'est aussi bon de nettoyer contre ça. Nous n'avons pas un tas d'encombrement dans notre base de données ici.
40. Subqueries: C'est bon. Dans cette leçon, nous allons passer en
revue quelque chose de vraiment cool qui vous
offre vraiment beaucoup de flexibilité en termes
de requêtes à
écrire, car cela vous
permet d'
imbriquer différents résultats. Ce que nous allons
apprendre dans cette leçon, c'est
ce que l'
on appelle les sous-requêtes. maintenant aux idées, et
revenons par exemple à notre tableau des lignes de
facture Nous pouvons maintenant écrire une requête SQL dans
laquelle il suffit, par exemple, de
regrouper par numéro de facture, puis de compter
le nombre d'occurrences. Nous pouvons obtenir un résultat
qui nous indique combien d'achats ont été
effectués avec chaque facture. Allons-y et
écrivons cette requête très rapidement. Nous allons d'abord avoir notre instruction SQL
squelette. Nous allons effectuer une sélection
dans le tableau des lignes de facture, et limitons les résultats à cinq pour le moment, jusqu'à ce que nous soyons
sûrs de notre requête. À partir de là, nous allons
sélectionner le numéro de facture. Maintenant, nous voulons également
exécuter une agrégation, et nous voulons simplement compter le nombre d'articles contenus dans le numéro de facture Pour ce faire, nous avons
également besoin d'un groupe par relevé et nous devons
regrouper par numéro de facture. Si nous l'exécutons et que nous
lui donnons un alias
sous forme de nombre d'éléments. Si vous êtes dans cette catégorie,
nous pouvons voir ici numéro de
facture 1, par exemple, contient deux articles achetés. Le numéro de facture 2 comporte quatre articles. numéro de facture 3 contient six éléments, et vous pouvez les supprimer
et y jeter un œil. Ici, nous pouvons voir à quoi ressemblent
nos données ici. Bien entendu, nous pouvons également le
commander,
par exemple, en fonction du numéro de
commande, du nombre d'articles, peut-être dans un ordre d'envoi. Nous pouvons voir ici toutes
ces factures d' achat d'un seul article, et si nous les lisons
plus bas, nous avons
maintenant les deux
colonnes d'articles, et ainsi de suite. Nous avons maintenant ces résultats. Mais que se passerait-il si nous voulions maintenant savoir combien de factures indiquaient l'achat de
deux articles ? En gros, nous avons exécuté
cette agrégation, et maintenant nous voulons
utiliser le résultat de cette agrégation ou peut-être
avons-nous exécuté une autre requête, et nous voulons utiliser le résultat de cette requête comme
point de départ pour la prochaine requête. Le problème est que, dans ce cas, nous ne pouvons pas vraiment utiliser, il y a
une faute de frappe d'ailleurs, nous ne pouvons pas vraiment utiliser cette colonne car cette colonne n'
existe qu' une fois la
requête terminée On ne peut vraiment
rien faire d'autre avec. Nous ne pouvons pas effectuer d'
agrégation supplémentaire en fonction du nombre d' éléments car la colonne
elle-même n'existe pas encore. Il n'existe qu'une fois
que nous avons exécuté cette requête. Alors, comment pouvons-nous alors utiliser les résultats de cette
étude et continuer ainsi ? Parce que les requêtes se
compliquent parfois et que vous
souhaitez exécuter une partie du
traitement et, sur la base du résultat, vous
souhaitez passer à autre chose. Vous voulez peut-être
effectuer un traitement. Sur le résultat, vous souhaitez ensuite
effectuer une agrégation. Sur la base de ce résultat, vous souhaitez effectuer une agrégation supplémentaire, mais maintenant sur la base d'un
cadre de référence différent, car vous disposez désormais différentes colonnes qui peuvent représenter des résultats
agrégés. Maintenant, pour ce faire, nous pouvons utiliser
ce que l'on appelle des sous-requêtes. Ce qu'est une sous-requête est
essentiellement une façon pour nous de dire : utilisons le résultat d'une requête
plutôt que d'une table spécifique. quoi
ressemble une sous-requête , nous avons
une instruction select, puis
une instruction ferme, comme avant. Mais au lieu
d'avoir une table ici, nous avons plutôt une requête. Ensuite, à la
fin, nous devons également
ajouter un nom pour une sous-requête. Par exemple, nous pouvons simplement
appeler cette sous-requête pour sous-requête. Nous pouvons reconnaître
le même format. Nous avons une instruction select, puis nous avons le F. Mais au lieu d'avoir
un nom de table ici, nous avons plutôt une requête complète. Ce que nous
sélectionnons ici est le résultat de
toute cette requête. Ensuite, nous lui donnons
également un alias et nous devons en fait donner un alias à
nos sous-requêtes Sinon, nous allons
avoir des problèmes. Nous lui donnons un alias, en l'appelant sub afin de
pouvoir y faire référence plus tard. Si nous l'exécutons, nous obtiendrons le même résultat car
tout ce que nous
faisons
pour le moment consiste simplement à sélectionner parmi les résultats, sélectionner toutes les colonnes à partir du résultat des sous-requêtes Mais bien sûr, nous pouvons
désormais faire des choses supplémentaires. Maintenant, par exemple, nous pouvons
accéder au nombre d'articles. Nous pouvons également toujours accéder
au numéro de facture,
car les deux ont été renvoyés à partir de notre
requête interne, de notre sous-requête. Regroupons maintenant en fonction du
nombre d'articles et comptons nombre de factures qui
appartenaient essentiellement à chacune
de ces catégories. Nous allons donc maintenant
afficher le nombre d' éléments. Nous n'avons pas besoin de le faire si nous n'avons
qu'une seule sous-requête, mais il est recommandé de faire référence
à
la sous-requête d' où
nous venons,
car si nous avons
plusieurs sous-requêtes, nous pouvons avoir colonnes
dupliqués Tout comme lorsque nous
le faisons lorsque nous faisons jointures ou quelque chose comme ça et que
nous devons
faire référence ou nous préférons référencer le tableau approprié pour le tableau approprié pour éviter toute confusion. De même, lorsque nous
utilisons des sous-requêtes ou généralement lorsque nous avons des
alias, par exemple, également uniquement pour les tables,
il est bon d'utiliser ces noms pour
nous assurer que nous référençons les Nous sélectionnons le nombre
de lignes dans notre sous-requête. Maintenant, nous voulons également exécuter à nouveau
une agrégation. Nous pouvons simplement compter
un, en bas, nous allons maintenant regrouper
par le nombre d'articles. Et passons à nouveau commande ici. Et ici, nous voulons passer commande, et peut-être devrions-nous d'abord
donner ce clou. C'est ici, on peut le dire,
le nombre de factures. Passons maintenant au classement en fonction du nombre de factures contenues
dans un ordre d'envoi. Cela n'a pas vraiment de
sens d'avoir l'
instruction order by ici,
car dans ce cas, nous n'utilisons pas le
résultat de l'instruction order by. Juste pour rendre les choses
plus efficaces, nous pouvons simplement retirer la
commande par relevé parce que nous ne
l'utilisons en aucune façon, et nous modifierons simplement
l'ordre plus tard. Nous pouvons l'emporter
ici car nous
ne l'utilisons pas dans certains cas, il se peut
que vous
utilisiez réellement la commande. Au cas où, vous pouvez le conserver
dans la sous-requête. Mais dans ce cas, nous n'
utilisons pas la commande, nous
allons donc la retirer. Je vais également
ajouter une indentation ici juste pour montrer que tout
cela fait partie de la même
sous-requête afin de la rendre
plus facile à voir, oui Si nous l'exécutons maintenant, et que nous fassions
défiler la page vers le haut, pour voir, nous avons 59 factures où
neuf articles ont été achetés chacune. 59 factures où
quatre articles ont été achetés chacune. En fait, nous avons
un grand nombre de 59 cas probablement parce qu'il s'agit
de l'ensemble de données pratiques. Ensuite, nous avons 117 factures, où deux
articles ont été achetés chacune. Nous pouvons voir maintenant que nous pouvons
utiliser des sous-requêtes pour utiliser le résultat d'une requête comme point de départ
pour la prochaine requête sous-requêtes sont vraiment
intéressantes car nous
permettent de
surmonter ces problèmes. Où nous avons juste quelques résultats et nous voulons continuer
à les utiliser, mais nous ne pouvons pas accéder aux colonnes
car elles n'existent pas encore car elles ne sont
créées qu'après l'exécution de la requête. Par conséquent, dans de nombreux cas vous
souhaiterez utiliser une sous-requête
afin de pouvoir continuer à utiliser
les résultats
de la requête précédente. Dans ce cas,
même si nous
renvoyons le numéro
de facture sur notre relevé ici, nous ne l'
utilisons pas ici. Juste pour garder les choses propres, nous pouvons même simplement le
retirer car nous ne l'
utilisons pas vraiment pour quoi que ce soit. Dans ce cas, nous pouvons simplement
supprimer le numéro de facture pour notre sous-requête
reste
propre, car là encore, nous n'avons pas besoin de l'utiliser Il est
donc inutile
de le renvoyer
car cela n'apportera pas beaucoup
de valeur ajoutée Parce que nous n'utilisons
que le nombre d'objets. Maintenant que nous avons
le nombre d'éléments, qui est le résultat
d'une agrégation, nous pouvons désormais utiliser cette
colonne résultante et, par exemple, exécuter à nouveau une agrégation sur celle-ci, les regroupant
désormais
en fonction des valeurs de cette colonne.
41. 39WindowFunctionsAndAliasesHB: Maintenant, nous avons déjà vu que nous pouvons faire beaucoup avec SQL, mais il y a des choses qui sont toujours sur Insert. Et l'une de ces choses, par exemple, est d'aller plus loin dans les agrégations. Parce qu'actuellement, lorsque nous exécutons des agrégations, nous nous concentrons principalement sur l'agrégation des résultats sur l'ensemble de la table. Mais parfois, nous ne voulons pas de résultats agrégés sur l'ensemble de la table, mais nous aimerions plutôt garder toutes les lignes et être en mesure d'avoir résultats agrégés
intermédiaires ou des résultats
agrégés qui sont en cours d'exécution de moyennes ou quoi que ce soit du genre. Allons donc de l'avant et voyons comment nous pouvons résoudre certains de ces problèmes. Donc, tout d'abord, écrivons simplement notre instruction SQL squelette ici. Et on va utiliser la table de piste ici. Alors allons de l'avant et il suffit de sélectionner tout de la table du camion en ce moment. Et tout d'abord, limitez nos résultats. Si nous faisons ça, nous pouvons voir ici, accord, exactement ce que nous attendons. Que se passe-t-il si, par exemple, nous voulons voir une agrégation en cours d'exécution sur les différents albums que nous avons ici. Et nous voulons savoir quel est le temps de course pour chaque morceau qui passe par l'album. Ou si nous voulons conserver les informations sur les lignes mais avoir toujours accès à la valeur agrégée. Comment pouvons-nous faire ça ? Actuellement, nous ne pouvons pas. Répondons d'abord à la deuxième question, qui est que nous voulons garder des informations sur toutes les lignes, mais nous voulons également avoir accès à la valeur agrégée. Donc ce qu'on va faire,
c'est tout sélectionner pour que nous puissions avoir cette information. Mais maintenant, nous voulons aussi être en mesure d'accéder à cette somme en cours d'exécution. Donc, ce que nous voulons faire, c'est nous voulons résumer les millisecondes ici pour garder une trace de l'heure de chaque chanson pendant que nous traversons l'album. Donc, nous voulons résumer sur la table des millisecondes ici, ou sur la colonne millisecondes plutôt. Mais si nous faisons cela, alors nous devons utiliser un groupe par déclaration. Mais il y a une autre façon que nous puissions réellement développer l'instruction, à savoir l'utilisation de fonctions de fenêtre. Donc, ce que nous pouvons faire, c'est que nous pouvons entendre juste et ensuite l'espace et ouvrir et fermer les parenthèses. Et à l'intérieur de l'instruction, nous pouvons alors créer des partitions en faisant partitionné par. Et finissons simplement la déclaration d'abord, puis revenons en arrière et regardez-la. Et partageons par l'idée de l'album. Donc, ce que cela signifie est que nous sélectionnons toujours toutes les colonnes, et nous allons faire une somme sur la colonne millisecondes, mais nous n'utilisons pas l'instruction groupe par instruction à la place, il y a une autre option que nous avons disponible qui a cette surestimer ici. Et donc à l'intérieur de cette surestimation, nous pouvons alors créer des partitions, qui est similaire à ce que nous ferions dans la clause group BY. Mais ici, nous définissons simplement comment nous voulons diviser nos données. Et plutôt que d'obtenir des résultats globaux retournés pour chaque colonne et d'avoir à les
inclure comme un peu la sortie basée sur ce que
nous avons dans le groupe BY, nous pouvons toujours prendre toutes nos colonnes et sorte de maintenir tous nos enregistrements. Mais nous pouvons avoir une colonne supplémentaire qui soit a une agrégation en cours d'exécution sont également juste une agrégation basée sur le groupe. Maintenant, la façon dont cette agrégation fonctionne dépend de ce qui grandit va être sélectionné. Donc, dans ce cas, si nous utilisons la partition BY, ce qui va se passer, c'est que nous allons diviser toutes nos données en différentes partitions en fonction de chaque ID d'album ici. Et pour chaque partition où Lincoln un exécuter cette agrégation, nous allons l'exécuter dans ce cas sur chaque partition. Donc, si on nous donne juste un pseudonyme, on peut appeler cette longueur d'album, la durée de
l'album ou tout ce que vous voulez. Et nous allons juste, exécutons ceci et jetons un oeil à la sortie. Et nous allons aussi enlever ou limiter la déclaration ici. Donc en cours d'exécution et puis en descendant à notre sortie ici, en se déplaçant tout le chemin vers la droite, nous avons ici notre longueur d'album. Et nous pouvons voir si nous faisons défiler vers le bas, cela va différer en fonction de l'ID d'album que nous avons. Nous avons donc une longueur d'album unique pour chaque ID d'album. Mais la chose intéressante dans la façon dont cela diffère du groupe par déclaration est que nous maintenons toujours sur toutes les lignes individuelles. Nous avons toujours toutes les informations sur les lignes individuelles. Nous avons également accès à la valeur agrégée. Et nous pouvons voir qu'ils diffèrent entre les différentes partitions ici. Donc, nous avons notre identifiant d'album un, et vous pouvez voir dans ce cas, toutes ces valeurs sont les mêmes. Nous avons notre album ID 2 ici. On a juste cette valeur. Nous avons un E3 ouvert d'esprit ici encore, les valeurs vont être les mêmes et pour quatre et ainsi de suite. Donc maintenant, nous avons l'agrégat, ou plutôt la somme sur cette colonne millisecondes pour chaque ID d'album. Donc diviser tout par les différents ID d'album et additionner sur les millisecondes. Mais parce que nous utilisons cette surestimation et nous utilisons des partitions ici. Plutôt que d'utiliser le groupe par déclaration, nous avons maintenant accès aux robots individuels. Donc, bien sûr, c'est génial lorsque vous avez également besoin d'avoir accès à ces autres données. Mais d'autres fois, l'instruction group by statement peut être mieux parce que vous allez obtenir une table beaucoup plus petite et vous allez principalement obtenir les résultats dont vous avez besoin si vous n'avez pas besoin d'avoir accès aux autres données ici. Donc encore une fois, cela dépend en quelque sorte de votre cas d'utilisation et de ce que vous avez
exactement besoin de ces résultats d'agrégation. Maintenant sont actuellement la valeur agrégée ici est la même dans toutes les colonnes, mais même cela n'a pas besoin de rester comme ceci. Maintenant, la façon dont cette agrégation fonctionne, encore une fois, cela dépend de la façon dont nous divisons nos données ici. Si nous utilisons simplement l'instruction de partition BY, alors ce qui se passe est pour chaque partition, toutes les lignes sont incluses. Mais nous pouvons également ajouter une autre clause ici, à savoir l'ordre par. Et c'est le même ordre que nous avons vu auparavant,
mais en interne pour chaque scission que nous faisons, dans ce cas par l'identifiant de l'album, nous pouvons également commander les résultats dans chaque scission. Et ordonnons, par exemple, par la colonne de nom. Et donc, ce qui se passe dans ce cas, si nous l'exécutons, nous allons en fait obtenir des valeurs différentes ici, même dans le même ID d'album. Et donc ce que vous pouvez voir d'ici, nous obtenons un total courant. Donc, dans ce cas, nous recevons un total de course jusqu'à cette chanson. C' est combien de temps, ces
deux chansons, et puis ici, c'est tous ces trois sons ensemble. Ici, c'est les quatre chansons. Et puis une fois que nous atteignons un nouvel album, le compteur se réinitialise. Et la raison pour laquelle cela est différent est que lorsque nous utilisons la
clause order by plutôt que toutes les lignes pour chaque partition considérée ensemble, nous considérons uniquement les lignes qui vont jusqu'à et y compris la valeur que nous ordonnons. Maintenant, s'il y a des doublons, tous ces doublons vont être pris en compte. Donc, si nous avons, par exemple, le nom de la seconde ici et la troisième chanson étant la même. Ensuite, la valeur agrégée que nous allons obtenir ici sera la même
dans les deux parce que nous passons dans les deux parce que nous passons par et il y a un doublon dans le nom, donc ce sera le même. Et il va aussi être égal aux trois premiers essentiellement parce que le premier ne sera pas unique dans le deuxième ou le troisième serait un duplicata. Et donc la valeur que nous obtiendrons ici serait celle pour les trois. Donc juste une sorte de choses à noter sur la façon dont ce comportement ou comment cela se comporte. Donc oui, comme nous pouvons le voir maintenant, nous pouvons avoir une autre façon d'aborder l'agrégation. Et l'un d'eux est le GroupBy et l'autre utilise cette surestimation. Et puis nous pouvons partitionner par différentes colonnes ici. Et si nous n'utilisons que la partition BY, alors les valeurs agrégées que nous allons obtenir seront fondamentalement dans chaque partition. Mais si nous ajoutons un ordre par clause deux, alors notre agrégation ne sera plus un dans chaque partition, mais plutôt agrégation en cours
d'exécution basée sur l'ordre que nous avons défini ici. Maintenant, que se passe-t-il si nous voulons faire quelques agrégations supplémentaires ? Donc, par exemple, nous avons la somme, mais peut-être que nous voulons aussi faire comme un compte courant parce que c'est une agrégation supplémentaire et que nous pouvons faire. Donc, nous pouvons aussi faire, par exemple, juste pour en rendre compte ici. Et peut-être que nous voulons aussi garder une trace de la longueur moyenne de la chanson deux. Donc, nous voulons aussi faire une moyenne de la colonne millisecondes peut-être. Ici, nous avons notre nombre de chansons d'albums, et ici nous avons notre longueur moyenne d'album. Donc, si nous allons de l'avant et relancez cela, et nous pouvons maintenant faire défiler un peu plus et regarder les résultats. Donc encore ici pour chacun d'entre eux, nous allons avoir une agrégation en cours d'exécution parce que nous utilisons la clause order by. Ici. Nous allons avoir un total courant, ou vous exécutez quelques millisecondes. Ici, nous allons avoir un comptage en cours d'exécution. Et ici, nous allons avoir une moyenne courante sur toutes les millisecondes. Donc, dans ce cas, nous pouvons voir que nous ne considérons
qu'une seule valeur, c'est pourquoi nous avons ici. Dans ce cas, ce sera la moyenne des deux premiers, qui est ce résultat ici. Voici la moyenne des trois premiers et ainsi de suite. Vous pouvez donc voir que nous pouvons utiliser les différentes fonctions d'agrégation et encore les utiliser sur ces différentes fenêtres. Mais dans ce cas, il n'est pas idéal de toujours répéter les déclarations ici. Idéalement, nous pourrions avoir un raccourci pour cela afin que nous ne
répétons pas cela parce que cela rend les choses plus difficiles à faire, cela rend plus difficile à lire. Mais aussi si vous voulez changer quelque chose, vous devez passer par et vous
devez le changer et chaque endroit. Et nous pouvons également créer des alias pour ces fenêtres ici. Donc, pour ce faire, nous allons descendre ici et nous allons définir la fenêtre. Ensuite, nous allons lui donner un nom d'alias ou nous allons juste lui donner
un nom pour qu' on puisse entendre dire album,
nom, scission par exemple. Et puis nous allons utiliser la déclaration. Et puis nous pouvons prendre la définition de cette fenêtre ici. Et on va le poser ici. Et puis à la place, nous pouvons utiliser cet alias que nous avons maintenant créé pour cette fenêtre ici à la place. Et donc avec cela, nous allons faire référence à ceci. Et ensuite on peut le mettre ici aussi. Et nous pouvons aussi le mettre ici. Maintenant encore une fois, cela a l'avantage que d'une part, cela devient plus facile à lire. Mais d'un autre côté, c'est aussi beaucoup plus propre à écrire parce que si nous voulons faire un changement à notre fenêtre ici, alors nous pouvons juste faire le changement d'un et il est propagé à tous les différents. agrégation est que nous faisons ici sont toutes les différentes utilisations. Alors que si nous copions simplement coller tout ce que chaque fois que nous faisons un changement, nous devons faire ce changement et chaque colonne différente, ce qui bien sûr ce n'est pas aussi agréable. Alors faisons ça et nous pouvons voir que
nous allons évidemment obtenir les mêmes résultats parce que rien d'autre n'a changé. On vient d'introduire un pseudonyme. Mais maintenant, si nous faisons autre chose, par
exemple, essayons de partitionner par ID d'album, mais aussi de partitionner peut-être par l'ID de genre comme une deuxième couche de partition. Maintenant, il est très probable que chaque album aura le même ID de genre. Mais peut-être qu'il y a des cas où un album a des pistes différentes qui ont des genres différents. C' est possible. Pas très probable dans de nombreux cas, mais c'est possible. Donc, dans les cas où il y a plus d'un genre, alors nous allons avoir une scission. Et s'il n'y a qu'un seul genre à l'intérieur, alors même si nous sommes divisés par l'ID de genre, parce qu'il n'y a qu'un seul genre ou des résultats, nous ne changerons pas. Donc, tout comme nous l'avons dans le groupe par déclaration, nous pouvons également ajouter d'autres ici. Donc, ce n'est pas seulement, ce n'est pas seulement une colonne que nous partitionnons cinq, nous pourrions en fait partitionner par plusieurs. La chose importante à garder à l'esprit avec ceci est juste que nous faisons d'abord cette partition, puis nous faisons cette partition. Et si nous en avons plus, nous le ferions après. Ainsi, l'identifiant de genre ne serait divisé qu'au sein de chaque groupe d'ID d'album. Donc juste une chose importante à garder à l'esprit. Mais maintenant, nous pouvons réexécuter ceci et vous pouvez voir que parce que nous n'utilisons pas d'alias, toutes ces modifications sont automatiquement appliquées à chaque façon où nous utilisons l'alias. Alors que si nous utilisons simplement la valeur copiée, nous aurions dû faire ce changement trois fois, qui d'une part est ennuyeux. Mais d'un autre côté, vous pouvez également oublier de faire le changement quelque part. Et alors vos résultats vont être faux, principalement parce que vous n'avez pas appliqué le changement partout et que ce sont des erreurs courantes qui se produisent. Ainsi, vous pouvez accélérer les choses, rendre les choses plus faciles à lire et moins vous soucier d'avoir ces types d'erreurs. Maintenant, en termes d'où cette définition irait dans notre format SQL complet. Donc ça va se passer si nous avons une déclaration where et nous allons avoir la fenêtre après, mais cela va aussi arriver avant la commande BY, alors disons que nous voulons dire quoi que ce soit et nous ne ferons aucun autre filtrage. Nous allons juste dire que nous suivons l'ID est supérieur ou égal à un. Et puis ici, nous allons avoir notre OrderBy. Et nous allons juste commander tout par ID album, ce qui serait probablement déjà. Mais on peut aller de l'avant et le refaire et juste dire un ordre croissant ici. Et c'est là que la définition alias de fenêtre doit aller. On prend ça et on le déplace ici et on fait ça. Ensuite, nous pouvons voir ici nous allons obtenir une erreur de syntaxe parce que encore une fois, nous avons besoin d'avoir des choses dans un ordre spécifique et donc cela n'appartient pas là. Il faut qu'on le ramène ici. Et si on recommence, tout va bien. Maintenant, nous pouvons voir que nous utilisons l'ascendant ici. Bien sûr, si nous utilisons l'ordre par clause et voici la même chose s'applique toujours. Nous pouvons également définir un dimanche ici, ou nous pouvons également utiliser le descendant. Et tout comme nous pourrions ajouter plusieurs choses ici dans la partition, nous pouvons également ajouter plusieurs choses ici sur OrderBy pour potentiellement résoudre des liens. Donc, par exemple, nous pouvons premier ordre par le nom et ensuite peut-être que nous voulons commander par autre chose, exemple, les octets. Et donc, dans ces cas, et encore
ici, nous ne allons pas faire des noms ascendants et blancs descendant puisque nous devons fournir le formulaire de commande pour chaque colonne que nous utilisons. Sinon, il va juste être supposé ascendant. Nous pouvons donc voir que nous avons beaucoup de flexibilité à cet égard aussi. Mais maintenant s'il y a une cravate dans la colonne de nom, plutôt que d'être utilisé dans l'agrégation pour comme une valeur en double. Au lieu de Skinner, regardez le deuxième ordre qui
va être dans la colonne octets et n'aura qu' un nombre en double et l'agrégation quelque part si le nom et les octets sont tous les deux les mêmes. Sinon, nous allons avoir une bonne commande en cours. Pour que nous puissions voir, nous pouvons exécuter ça encore et encore. On peut juste voir nos résultats ici. Et le tableau ci-dessous.
42. 40RowNumbersAndRanksHB: Maintenant, nous venons de voir comment nous pouvons utiliser les fonctions de fenêtre pour faire des agrégations sur des parties individuelles de partitions que nous définissons. Mais avec 10 fonctions, nous pouvons non seulement faire des agrégations, mais nous pouvons faire d'autres choses telles que compter les numéros de ligne. Et cela peut également être vraiment utile. Alors jetons un coup d'oeil à la façon de le faire maintenant. Et pour cela, nous allons utiliser la table des lignes de facture. Et ce qu'on va faire, c'est qu'on va faire un je suis idiot, un peu diviser et juste tout diviser par le prix unitaire, ou plutôt tout partager par le prix unitaire pour
que nous ayons des valeurs en double. Et puis nous pouvons voir comment ces différentes choses affectent tout ça. Allons de l'avant et écrire sont juste squelette sélectionner. Nous allons écrire tout sélectionner à partir de la table de ligne de facture, juste en plaçant un point-virgule ici. Bon, donc nous allons tout sélectionner et maintenant nous allons
avoir nos fonctions de fenêtre ici. Donc la première chose que nous pouvons peut-être regarder est le numéro de ligne. Donc juste garder une trace du numéro de ligne qui se trouvait dans chaque partition. Donc, pour ce faire, au lieu de mettre une fonction d'agrégation ici, nous pouvons à la place mettre dans la fonction de numéro de ligne, qui ne prend pas d'entrée. Et puis nous allons avoir notre format de fonction de fenêtre standard que nous avons également vu auparavant, où nous faisons un plus. Et maintenant, nous définissons ce que nous voulons partitionner BY. Alors partageons par le prix unitaire. Et faisons aussi quelques commandes. Commandez par la carte d'identité du camion. Et ceci ici, nous pouvons juste mettre comme numéro de ligne. Maintenant, pour cela, nous allons certainement obtenir des valeurs en double parce que, bien sûr, il y aura probablement des achats informatiques en double piste. Donc, nous pouvons voir que nous sommes en train de grouper ou plutôt nous partitionnons par le prix unitaire ici et ici. Commande d'oiseau par le camion ID dans chaque partition. Dans ce cas, il est probable que tout a un prix unitaire de 0,99$. Et donc nous avons juste une grande partition qui a cette commande. Et dans ce cas, nous pouvons voir juste en regardant les numéros de ligne, nous avons toujours le numéro de ligne incrémentielle est même si nous avons des valeurs en double ici. Maintenant, si nous avons défini plus loin sont de commander non seulement par ID de camion, mais aussi par ID de facture, alors nos résultats ici ne vont pas vraiment
changer juste parce que pas beaucoup d'autre a changé. Donc, nous pouvons toujours garder une trace de l'individu surgi ici, et nous pouvons encore faire d'autres commandes. Mais il existe également différentes façons de compter les numéros de ligne. Donc, dans ce cas, nous donnons un numéro de ligne pour chaque ligne que nous
avons , peu importe s'il y a une valeur en double ou non. Reprenons cet ordre ici encore. Mais parfois on ne veut pas ça. Parfois, nous voulons que les valeurs en double aient le même numéro de ligne. Et pour ce faire, nous pouvons utiliser une fonction appelée rang. Encore une fois, il ne prend aucune entrée. Et juste pour chaque, au sein de chaque partition, nous allons ensuite donner un rang à chaque ordre par industrie que nous avons un plutôt par chaque entrée que nous avons. Mais le rang est différent en ce que les valeurs dupliquées, comme nous pouvons le voir ici, se voient attribuer le même numéro de ligne. C' est probablement mieux si nous mettons à jour ceci au rang. Mais le rang est encore une fois juste une forme de numéro de ligne. Mais pour les valeurs en double, ils vont avoir le même rang. Donc, vous pouvez voir ici c'est 1, 2, et ce serait trois, mais c'est un duplicata parce que lorsque nous commandons par l'ID du camion, sont les mêmes valeurs. Donc, dans cette partition d'un prix unitaire de 0,99, les valeurs d'ID de camion ici sont les deux lignes ici sont des doublons parce que encore, ils ont le même ID de camion. Donc, dans ce cas, ils ont le même rang. Et nous pouvons voir une fois que nous passons à 45678 et ainsi de suite jusqu'à ce que nous atteignions un autre duplicata. Et puis ils auront le même rang. Mais ensuite, nous continuons à compter et à garder une trace du nombre de doublons ici, puis continuons à compter sur endroit où nous aurions si nous utilisions les numéros de ligne à la place. Maintenant, cela peut être vraiment agréable parce que parfois vous ne voulez pas affecter des numéros de ligne sont des numéros de ligne différents quand il y a des instances en double. Et donc le rang peut également être une chose très utile à utiliser. Mais il y a aussi d'autres cas où vous ne voulez pas sauter des nombres et vous n'avez pas autant
intéressé par le numéro de ligne absolu plutôt que l'ordre complet dans
lequel les choses vont et vous voulez juste avoir une sorte de cohérence commande consécutive. Et ce que vous faites, vous pouvez utiliser pour cela est quelque chose appelé un rang dense ou la fonction de rang dense. Et donc si nous exécutons ceci, le changement que nous avons est plutôt que dans ce cas, par exemple, d'
avoir un quatre parce que nous avons deux deux deux ici, nous allons juste continuer à compter sur le prochain nombre consécutif. Donc, il n'est plus important, c'est combien de doublons nous avons. Nous ne allons pas sauter autant de chiffres, mais plutôt nous allons continuer à compter à partir du prochain numéro. Maintenant encore une fois, ceci est spécifique pour chaque partition que nous avons. Dans ce cas, l'utilisation du prix unitaire nous a permis de créer une partition où nous pouvons être sûrs qu'il y a quelques doublons pour les ID de camion ici. Mais bien sûr, si vous avez, vous savez, plusieurs partitions que votre rang, ou dans ce cas, ce sera en fait le rang dense ou aussi les numéros de ligne. Ils vont être spécifiques à chaque partition. Ils ne vont pas passer sur toute la table. Ils vont être spécifiques à chaque partition. Donc, c'est juste une chose importante à garder à l'esprit, que votre rang, votre rang dense, ou même votre numéro de ligne vont être réinitialisés et qu'ils ne seront définis que dans chaque partition est divisée que vous avez ici. Maintenant, si vous vouliez le trouver sur la base de données, ce que vous pouvez faire est au lieu de se fractionner par n'importe quoi, et peut-être que vous n'avez même pas une colonne qui a la même valeur partout. Vous pouvez simplement enlever cette déclaration de partition et laisser simplement l'instruction order BY. Et, et de cette façon, notre fonction de fenêtre va toujours fonctionner, mais maintenant nous ne partitionnons plus par quoi que ce soit. De cette façon, nous passons d'avoir le rang ou le rang dense ou le numéro de ligne spécifique à chaque partition. Mais au contraire, nous l'avons pour l'ensemble du jeu parce que nous ne créons plus de partition.
43. 41UsingOtherRowsRetraitsRepellementHB: Très bien, donc nous avons eu un coup d'oeil aux fonctions de
fenêtre et nous avons vu des choses cool que nous pourrions faire avec cela en
faisant spécifiquement des agrégations en cours d'exécution sont des agrégations basées sur les partitions sans sacrifier aucune des informations que nous avons dans les lignes individuelles. Maintenant, cependant, à un moment donné, il est probable que vous voudrez probablement accéder aux informations d'autres lignes. Par exemple, peut-être que vous voulez
savoir sur deux achats consécutifs ou
11 achats se sont produits lorsque le prochain achat se produira ou, ou quelque chose comme ça. Actuellement, la façon dont nous utilisons les données est que chaque ligne est en quelque sorte traitée individuellement. Et pour l'instant, il n'y a aucun moyen pour nous d'accéder à l'information des autres routes. Alors jetons un coup d'oeil à ça maintenant. Et nous allons utiliser la table des factures pour ça. Et allons juste de l'avant et écrire nos instructions SQL squelette. Nous allons dire tout sélectionner dans la table des factures. Allons de l'avant et limitons nos résultats à cinq pour l'instant. Allez-y et exécutez ça. Donc, ce sera nos résultats ici. Et maintenant, essayons de créer une ligne ou une ligne de conditions commerciales afin qu'avec chaque ligne que nous avons, nous ayons la colonne de date de la facture et nous avons aussi quelque chose appelé l'état suivant, qui en ce moment va juste être la voix de la date de la prochaine facture, peu importe s'il s'agit du même client ou de quelque chose du genre. Nous allons juste avoir une nouvelle colonne qui nous donne la date de la prochaine facture. Alors, comment pouvons-nous faire ça ? Eh bien, la façon dont nous pouvons le faire, c'est d'utiliser nos fonctions de fenêtre. Mais ce qu'on va faire ici, c'est qu'on va utiliser quelque chose appelé Read. Maintenant, ce que nous faisons avec le plomb lorsque nous mettons en deux paramètres, le premier va être une colonne dont nous voulons l'information suivante. Donc, dans ce cas, nous voulons utiliser la date de facturation. Et sur l'autre paramètre que nous avons, c'est jusqu'où voulons-nous aller ? Ainsi, par exemple, nous voulons prendre la valeur de la ligne suivante. Ensuite, nous allons utiliser le prospect sur la date de facturation et nous allons aller de l'avant. Donc, par exemple, pour cette ligne actuelle et ce que le prospect va faire, c'est que cela va nous permettre d'
accéder à la valeur à partir d'une ligne plus loin dans la date de facturation. Si nous en faisons deux, si nous étions cette rangée, nous chercherions à des lignes plus loin. Donc c'est comme ça que nous pouvons définir ça ici. Combien de rangées voulons-nous aller devant ? Alors restons-en avec un. Maintenant, pour terminer cela, nous devons également définir à nouveau la partition que nous voulons parcourir spécifiquement en utilisant les fonctions de fenêtre. Mais comme nous l'avons vu précédemment, nous n'avons pas vraiment besoin de définir la partition si nous ne le voulons pas. Donc, si vous voulez juste utiliser la table complète, ce que nous allons faire pour l'instant. Nous allons simplement utiliser la clause order BY et nous allons juste commander par date de facture. Donc tout va être commandé par date de facturation. Et pour chaque ligne, nous allons juste avoir la prochaine date de facturation. Et allons de l'avant et donnons cet alias de colonne, en l'appelant la prochaine date de facturation. Et si nous allons de l'avant,
et allons de l'avant et jetons un coup d'oeil. Notre sortie. Ici, nous avons la prochaine date de facturation, et ici nous avons la date de facturation actuelle. Et nous pouvons voir que cette valeur est juste égale à ce que nous avons pour cette valeur ici. Vous pouvez donc voir que nous prenons toujours la valeur suivante de
la colonne de date de la facture et l'avons dans notre ligne actuelle. Maintenant, nous pouvons bien sûr aussi faire plus avec cela. On peut faire une partie de l'arithmétique. Donc, nous avons aussi appris avant. Par exemple, si nous voulons obtenir la différence de temps pour la prochaine facture, alors prenons simplement notre déclaration ici, et copions simplement tout. Posez-le ici, et mettez à jour l'alias de colonne pour indiquer l'heure à la prochaine facture. Et ce qu'on va faire, c'est qu'on va prendre la date de la facture et qu'on va examiner ça. Nous allons utiliser cette fonction de plomb ici pour obtenir la valeur suivante. Et puis à partir de là, nous pouvons simplement soustraire la date actuelle de la facture. Donc, si nous allons de l'avant et que nous ayons une colonne supplémentaire ici. Et maintenant, on peut voir, d'accord, quel est le décalage horaire pour la prochaine date de facturation ? Donc, dans ce cas, nous avons une différence de temps d'un jour, que nous pouvons également voir ici. Et en fait, sélectionnons simplement la colonne de date de facture ici afin que nous puissions
tout comparer côte à côte. Donc, en cours d'exécution encore. Donc, nous avons ici la date de facture actuelle, la prochaine date de facture, qui vient de l'utilisation de cette fonction de prospect sur la colonne de date de facture. Nous prenons donc la valeur suivante, car c'est celle de la colonne de date de facture qui est ici. Nous pouvons voir que ici les différences de temps un jour entre cette valeur et cette valeur. Là encore, la différence de temps est d'un jour entre celui-ci et celui-ci. Ici, la différence de temps est de trois jours entre celui-ci et celui-ci. Et pour que nous puissions voir, nous utilisons simplement la valeur de la ligne suivante. Et bien sûr, nous pouvons continuer à utiliser notre arithmétique ici. Il est juste important de noter l'ordre dans lequel nous utilisons l'arithmétique en ce sens que nous le
faisons après avoir défini notre fenêtre ici. Parce que lorsque nous utilisons des fonctions de fenêtre, comme le plomb ici, par exemple, nous devons nous assurer que l'ovaire. Et le mot clé, il vient ensuite. Donc nous devons avoir tout cela comme une déclaration de groupe. Et ensuite, nous pouvons faire, par exemple, le moins tel que nous l'avons ici. Encore une fois, nous n'avons pas seulement besoin de sélectionner dans la colonne suivante. Nous pouvons également aller, ou plutôt à partir de la rangée suivante, nous pouvons également aller aux lignes en avant ou simplement changer cela pour être un deux. Et si on va faire ça, tu peux voir ici maintenant qu'on est en train de sauter deux casquettes Rho. Donc, cette valeur ici est pour cette ligne, deux lignes plus loin. Donc nous pouvons voir celui-ci vient ici, ce 12 rangées plus loin, celui qui va ici. Donc, vous pouvez voir que ce n'est pas seulement limité à une rangée. On peut définir le saut que l'on veut faire. Et si on veut reculer ? Et si au lieu de regarder la prochaine rangée ou le prochain pro après ça ou après ça ou,
vous savez, quoi que ce soit d'autre. Et si nous voulons revenir en arrière à la place, nous voulons regarder la rangée précédente. Donc, ce que nous pouvons faire ici est au lieu d'utiliser
le plomb, la fonction que nous voulons utiliser ici est appelée le décalage. Et ici, nous pouvons ensuite mettre à jour notre nom et dire l'équipe de facturation précédente. Et nous pouvons faire la même chose ici en utilisant le LOG au lieu du plomb. Et on va obtenir la même chose. Faisons juste la ligne précédente plutôt que deux lignes précédentes. Et nous allons avoir la même chose sauf dans ce cas, nous avons, nous regardons la tête de rangée plutôt que la rangée suivante. Ici. Nous devons également mettre à jour cette fois depuis la facture précédente. Maintenant, il va y avoir quelque chose d'intéressant ici et nous n'avons pas considéré où nous n'avons pas rencontré l'autre cas que je viens de la tête, mais nous verrons quand nous lancerons ceci, la première valeur ici va être nulle. Et c'est parce qu'il n'y a rien avant le premier rang. Et la même chose arrive avec le plomb quand nous atteignons la dernière rangée. Ou si vous avez ici peut-être deux ou trois. Si nous atteignons la deuxième perte pour la troisième dernière ou quel que soit le nombre que nous avons ici, ligne et chaque ligne après cela, nous allons avoir une valeur nulle dans ces colonnes. Juste parce que ces valeurs n'existent pas, n'est-ce pas ? n'y a pas, est-ce si c'est notre première ligne, il n'y a pas de ligne précédente à la première ligne, donc ces valeurs vont être nulles. De même, quand nous arrivons à notre dernière ligne, il n'y a pas de ligne après la dernière rangée. Et donc ces valeurs doivent être nulles. Donc, c'est juste quelque chose qui vient en quelque sorte de l'informatique et quelque chose dont il faut être conscient. Mais encore une fois, ici, nous pouvons utiliser la fonction de verrouillage avec cette fenêtre que nous avons définie ici pour obtenir l'accès aux valeurs dans les lignes précédentes. Et bien sûr, nous n'avons pas seulement besoin d'utiliser la date de facturation. Nous pouvons utiliser n'importe quelle autre colonne dans 1D. Nous pouvons simplement définir quelle colonne nous voulons accéder à la valeur précédente. Combien de lignes nous voulons aller en
avant ou en arrière selon si vous utilisez le décalage ou le plomb. Et puis aussi la fenêtre que nous voulons utiliser. Et ce cas parce que nous n'avons pas défini de partition, nous utilisons simplement l'ensemble de données, mais nous pouvons également le faire sur une base de partition. Par exemple, nous pourrions essayer de partitionner par ID client. Donc, vous pouvez configurer ça. Nous pouvons dire partition BY, et ensuite nous allons utiliser l'ID client. Et ensuite on pourra faire la même chose ici. Et à ce stade, parce que nous utilisons déjà deux et nous avons dû faire le copier-coller et probablement bon pour définir un alias. Nous allons rapidement dire fenêtre ici et nous allons définir notre fenêtre ou probablement pas utiliser vers l'extérieur. Donc nous allons juste dire w As et mettre ça ici. Et passez plutôt sur W, où nous n'avons pas à faire face à ces problèmes de copier-coller. Alors allons-y et continuons encore une fois. Donc vous pouvez vous voir maintenant, nous venons de créer un alias dont nous avons appris plus tôt. Donc nous revenons à la rangée précédente. Mais dans ce cas, nous avons créé une partition par ID client. Allons donc aussi de l'avant et regardons notre identifiant client. Et nous pouvons également voir ces informations pour vous. Allez-y et exécutez ça, d'accord, alors nous avons toutes les factures pour l'ID client 1. Et il est également de changer l'ordre des colonnes ici juste pour avoir des choses plus faciles à comparer. Donc, les premières idées de costumes, la première colonne que nous pouvons jamais inverser l'état ainsi que la date de facture précédente et l'heure depuis. Vous avez donc un numéro d'identification client, leurs achats et essentiellement chaque point ici, l'heure de l'achat précédent et la différence de temps. Et si nous supprimons notre déclaration de limite, alors nous pouvons bien sûr obtenir les informations. Et aussi pour les autres partitions clients qui plafonnent. Vous pouvez voir à un moment donné en fonction, vous savez, nombre de clients ou du nombre d'achats qu'un client a. Parfois, un client n'a qu'un seul achat, alors tous d'entre eux, nous verrions , par
exemple, serait juste un null. Dans ce cas, ces clients ont tous plusieurs achats. Mais bien sûr, si nous créons des partitions, il n'est pas improbable que certaines de nos partitions ne contiennent qu'une valeur d'une. Mais la chose importante ici à voir est que lorsque nous utilisons les partitions,
encore une fois, à cause de la façon dont les fonctions de fenêtre fonctionnent, nous calculons cela sur chaque fenêtre. Et donc nous pouvons voir que même si ici il y a probablement une date qui s'est passé avant cela, parce que cela est spécifique au groupe d'ID client huit. Nous n'avons aucune valeur ici puisque c'était la date
du premier achat de l'ID client 8. Encore une fois, un peu le même principe avec la partition que nous avons également vu dans l'agrégation quand nous avons appris sur les fonctions de fenêtre d'abord, qu'ici notre fonction de fenêtre, ou plutôt la fonction que nous appliquons sur cette fenêtre, à nouveau va être spécifique à chaque partition. Et il va aussi être bordé par la déclaration que nous avons ici.
44. 42NTilesHB: Maintenant, dans certains cas, nous pouvons vouloir diviser nos données en différents compartiments et également, ou plutôt avoir des données dans des compartiments de tailles égales. Donc, ce serait peut-être que nous pouvons faire une sorte d'
analyse de bloc ou de compartiment ou toute autre application pour laquelle nous essayons de l'utiliser. Alors, comment pourrions-nous utiliser SQL pour peut-être déjà créer des compartiments pour nous que nous pouvons utiliser ou plutôt mettre des nombres à chacune de nos lignes et les diviser fondamentalement en compartiments. Donc encore une fois, nous pouvons le faire en utilisant des fonctions de fenêtre, et nous allons à nouveau utiliser la table de facturation ici et une écriture de notre instruction SQL squelette, juste en sélectionnant tout dans la colonne de facture. Et il suffit d'aller de l'avant et de limiter les résultats à cinq au début. Allez-y et exécutez ceci juste pour que nous ayons déjà un résultat. Bon, alors divisons notre seau et deux groupes de taille égale. Encore une fois, nous allons utiliser une fonction de fenêtre ici. Ce que nous allons faire, c'est que la fonction est appelée n-type, ce qui nous permet de définir combien de compartiments de taille égale nous voulons diviser nos données en R dans lesquels nous voulons affecter nos données. Donc, par exemple, si nous disons et cinq, cela signifie
que nous allons le mettre dans cinq seaux de taille égale ou aussi égale que possible. Jetons donc un coup d'oeil à cette sortie et faisons réellement cela. En fait, il fera la fenêtre, pourquoi partitionner sur l'ID client pour s'assurer que nous pouvons réellement voir les différences. Donc, puisque nous utilisons une fonction de fenêtre ici, nous allons devoir utiliser le mot-clé. Maintenant, nous allons partitionner par l'ID client. Et encore une fois, commandez par date. Et avons une date de facture. Et donnons à ceci un alias ou nous disons le numéro de compartiment. Et prenons aussi notre déclaration de limite ici. Et, euh, allez-y et exécutez ça. Bon, donc défiler jusqu'à droite où va se trouver notre dernière colonne. Nous avons ici notre numéro de seau. Et en fait, prenons juste un nombre réduit de colonnes ici puisque nous ne les utiliserons pas de toute façon. Donc, nous prendrons l'identifiant du client, nous prendrons la date de la facture car c'est ce que nous
partageons ainsi que ce que nous commandons et exécutons cette fois de plus. Donc nous avons un numéro d'identification de client ici. Et nous pouvons voir que nos achats ici ont essentiellement été divisés en seaux aussi égaux que possible. On n'est pas en mesure d'entrer dans tout. Mais nous pouvons voir ici la première année que j'ai été regroupé en seau 1, deuxième 2, ou numéro 3, et 4 de seau congruent au prochain 1345. Donc, en essayant d'obtenir le plus égal possible, mais il n'y a pas de distribution parfaitement équilibrée. Alors on peut arriver ici. Puis passer au compartiment suivant pour l'ID client 2. Encore une fois, nous avons les diviser en différents seaux. Et ce cas, nous avons en fait le même nombre d'achats pour client avec id1 et le client avec id2. Donc, dans ce cas, juste parce que nous utilisons un jeu de données pratiques, il semble que tous les clients ont en fait un nombre très égal d'achats. Donc, toutes les distributions de compartiments que nous recevons ici, vous serez les mêmes pour les différents ID client. Encore une fois, juste parce que chaque client a effectivement un nombre très similaire d'achats, sinon un nombre identique d'achats. Mais nous pouvons encore jouer avec nos tailles de seau ici. Par exemple, si nous utilisons sept, c'
est-à-dire le nombre d'achats que chaque client a réellement. Nous pouvons voir que nos seaux ici nous allons être maintenant égaux un et chacun pour la place utiliser trois. On va s'attendre à trois dans les 12 premiers dans les autres. Donc, nous pouvons utiliser la tuile n ici pour définir combien de compartiments de, idéalement sont de taille approximativement égale, nous voulons diviser nos données en. Et il va juste les mettre dedans. Et encore une fois avec la première sorte d'obtenir le plus de valeurs bébé ne peut pas remplir. Le fond est qu'ils en auront un de moins. Mais essayer de diviser nos données en deux compartiments égaux en fonction de la partition que nous avons définie ici, et également en fonction de l'ordre que nous avons également défini dans notre fenêtre ici.
45. 43ComprendezReprendreRetraqueHB: Maintenant, si vous entrez vraiment dans SQL, peut-être que ce sont quelques points. Vous voulez également en savoir plus sur la façon dont vos requêtes sont planifiées
ou structurées ou sur l'approche adoptée pour l'exécution et peut-être une autre optimisation des étapes que vous pouvez faire. Donc, pour ce faire, exécutons un petit exemple de requête sur la table des pistes. Et nous allons simplement lancer une agrégation pour compter le nombre de pistes dans chaque album. Nous allons donc lancer la sélection et nous allons sélectionner l'ID de l'album. Et ce qu'on veut aussi faire, c'est d'en compter un comme des camions de bois. Et nous allons juste avoir cette capitale juste pour le rendre plus facile à lire à partir de la table de piste. Et puis nous avons encore besoin de regrouper par l'ID de l'album. Encore une fois, nous sélectionnons à partir de la table des camions et nous sommes regroupés par l'ID de l'album et nous comptons juste le nombre de camions que possède chaque album. Donc, si nous allons de l'avant et exécutons
ça, ce sont les résultats que nous allons obtenir. Il s'agit de l'ID de l'album et c'est le nombre de pistes qu'il possède. Mais maintenant, si on veut comprendre sa performance, ça va être un peu difficile. Donc, SQL a en fait une instruction disponible pour nous appelée Expliquer. Et si on fait ça, on peut y jeter un coup d'oeil. Au lieu de nous donner la sortie telle qu'elle est, au lieu de nous donner le plan de la requête. Maintenant, je ne vais pas entrer dans les détails, mais le plan de requête, parce que le plan de requête lui-même l'est, peut devenir assez complexe. Et si vous voulez vraiment travailler sur ces optimisations, alors vous devrez probablement faire quelques recherches supplémentaires spécifiquement pour
comprendre le fonctionnement de l' agrégation, mais aussi sur la façon dont votre base de données que vous utilisez est car différentes bases de données fonctionnent réellement. agrégations sont également simplement des requêtes en général différemment. Parce que lorsque nous écrivons des requêtes, nous disons simplement à la base de données ce que nous voulons faire. Et la base de données elle-même fonctionne et trouve le moyen le plus optimal d'obtenir ces valeurs. Et donc cela peut différer d'une base de données à fonction de la façon dont la base de données fonctionne et comment en
fonction de la façon dont la base de données fonctionne et comment
elle respire et droits,
comment elle planifie et comment c'est comment les valeurs sont indexées et tout cela. Donc, encore une fois, cela va en quelque sorte être plus profond dans la façon dont la base de données elle-même en tant que mise en place. C' est pour ça qu'on ne va pas y plonger. Mais néanmoins, il est important de savoir que cette option est disponible pour vous. Vous pouvez donc utiliser l'instruction d'explication pour comprendre le plan, que le plan de requête, comment la base de données prévoit d'
exécuter la requête pour obtenir les résultats que vous recherchez. Et puis vous pouvez également comprendre, vous savez, combien de lignes sont traitées ou combien de colonnes sont utilisées et dans chaque composant. Ou vous pouvez aussi faire quelque chose comme Expliquer, Analyser, qui vous indique également le temps de calcul, le temps d'exécution plutôt que le temps d'exécution réellement pris. Pour que vous puissiez approfondir compréhension de chacun de ces composants de sorte que, vous savez, vous pouvez
peut-être trouver où la requête prend le plus de temps et travailler à l'optimisation de cela. Ou peut-être que vous comprenez que le, ou peut-être que vous trouvez que l'approche que vous prenez est optimale dans une base de données, mais c'est en fait manquer un sous-optimal en raison de la façon dont il a été mis en place. Et de cette façon, vous êtes en mesure d'approfondir vos requêtes et d'effectuer grandes optimisations en comprenant la structure et
l' approche que votre base de données a en quelque sorte définie comme vous l'avez fait Howard veut aborder l'exécution de cette pour obtenir les résultats que vous avez demandés.