Différence entre l'algèbre relationnelle et le calcul relationnel

Question

Quelle est la différence exacte entre l'algèbre relationnelle et le calcul relationnel. Au plus de la référence, il sera

Relational algebra is procedural and calculus is non procedural.

Alors, qu'est-ce que cela signifie? Cependant, nous pouvons résoudre tous les problèmes en utilisant l'algèbre relationnelle. Alors pourquoi nous utiliserions le calcul relationnel. Sauf définition, l'explication avec l'exemple est très appréciée.

philipxy · Answer

TL; DR: Requêtes appelant des opérateurs RA (algèbre relationnelle) et requêtes des deux calculs relationnels (RC) TRC (Tuple RC) & DRC (domaine RC ) sont une syntaxe différente pour la même chose: une valeur de relation ou la propriété/condition que les tuples d'une valeur de relation doivent remplir. Tout comme SQL (un mélange (en haut)). Tout comme le calcul prédicat, le langage de la précision en mathématiques, logique, science (y compris informatique) et ingénierie (y compris génie logiciel). Et RA comme procédurale vs RC comme déclarative est un mythe.

Une relation contient les tuples qui font du prédicat - modèle d'instruction paramétré par des attributs - en une vraie proposition - -déclaration.

/* tuples where employee PERSONNAME lives on STREET in CITY */ Employee /* tuples where employee PERSONNAME works at COMPANY for $SALARY */ WorksFor

Une expression de requête de style RA implique des noms d'attribut, des noms de variable/constante de relation, des littéraux de relation (impliquant des noms et des valeurs d'attribut) et des opérateurs de relation. Les opérateurs sont JOIN, UNION, MOINS, PROJECT, RESTRICT, etc. Il indique la valeur de relation que vous obtenez en évaluant l'expression. Mais ce sont aussi des exigences que la valeur doit satisfaire.

/* RA query for tuples where FOR SOME STREET & CITY [employee PERSONNAME lives on STREET in CITY] AND NOT FOR SOME COMPANY & SALARY [employee PERSONNAME works at COMPANY for $SALARY AND COMPANY = 'FBC'] */ PROJECT PERSONNAME (Employee) MINUS PROJECT PERSONNAME (RESTRICT COMPANY = 'FBC' (WorksFor))

Une expression RC est notation set-builder pour une valeur de relation. Il implique un prédicat avec des noms de variables/constantes de relation, des noms et valeurs d'attributs, des opérateurs de prédicats et des noms quantifiés (variables logiques). Les opérateurs sont ET, OU, NON, POUR CERTAINS/TOUS et =. Il est généralement considéré comme une exigence de la valeur à respecter. Mais cela dénote également la valeur de relation que vous obtenez en évaluant l'expression ou une certaine équivalente.

La RDC a des noms quantifiés qui sont des attributs. Nous utilisons un raccourci pour les déclarations avec un paramètre par attribut:

Employee(PERSONNAME, STREET, CITY) means (PERSONNAME, STREET, CITY) IN Employee means employee PERSONNAME lives on STREET in CITY WorksFor(PERSONNAME, COMPANY, SALARY) means (PERSONNAME, COMPANY, SALARY) IN WorksFor means employee PERSONNAME works at COMPANY for $SALARY /* DRC query for the same tuples as the RA query above */ tuples like (PERSONNAME) where FOR SOME STREET & CITY [Employee(PERSONNAME, STREET, CITY)] AND NOT FOR SOME COMPANY & SALARY [WorksFor(PERSONNAME, COMPANY, SALARY) AND COMPANY = 'FBC']

Le TRC a des noms quantifiés qui sont des tuples. Nous dotons un nom pour obtenir la valeur associée à un nom d'attribut. (Comme pour un champ d'un enregistrement de langage de programmation.) Nous utilisons un raccourci pour les instructions avec un paramètre (un tuple):

Employee(T) means T IN Employee means employee T.PERSONNAME lives on T.STREET in T.CITY Worksfor(T) means T IN Worksfor means employee T.PERSONNAME works at T.COMPANY for $T.SALARY /* TRC query for the same tuples as the RA query above */ tuples equal to some Tuple T like (PERSONNAME) where FOR SOME E [Employee(E) AND E.PERSONNAME = T.PERSONNAME] AND NOT FOR SOME W [ WorksFor(W) AND W.COMPANY = 'FBC' AND E.PERSONNAME = T.PERSONNAME ]

(Quelques variantes sur les originaux des RA et des RC sont enseignées. Par exemple, certaines identifient les arguments par ordre et d'autres par leur nom. Parfois, des capacités supplémentaires sont ajoutées. Par exemple, autoriser un appel de fonction dans un RC est aussi expressif que permettre une certaine relation constante plus opérateur [~ # ~] r [~ # ~] RENAME [~ # ~] a [~ # ~] TO [~ # ~] n [~ # ~] dans une RA.)

Cependant, il existe une correspondance entre les opérateurs RA et les opérateurs RC et entre les expressions RA et les expressions RC:

Si:
• R - contient les tuples où R (...)
• S - contient des tuples où S (...)
puis:
• R JOIN S contient des tuples où R(...) AND S (...)
• R UNION S contient des tuples où R(...) OR S (...)
• R MOINS S contient des tuples où R(...) ET PAS S (...)
• R PROJECT colonnes à conserver contient les tuples où POUR CERTAINS colonnes à supprimer, R (...)
• R RESTRICT condition contient les tuples où R(...) ET condition

La valeur d'une expression RA correspond aux tuples qui satisfont l'expression RC correspondante.

Si nous voulons mapper d'une expression RC à une expression RA sur une base opérateur par opérateur, nous avons besoin d'opérateurs RA étendus: un généralisant UNION et un correspondant à NOT. Ce ne sont pas des opérateurs que nous aimerions réellement utiliser dans une implémentation - les valeurs des relations renvoyées sont dans un certain sens excessivement grandes. Mais chaque expression RC qui les utilise peut être réorganisée mécaniquement en une forme normale qui utilise uniquement des opérateurs RA de base.

Donc: RA comme procédural vs RC comme déclaratif est un mythe. Chaque opérateur RA a un opérateur RC correspondant, chaque opérateur RC a un opérateur RA correspondant (éventuellement étendu), et chaque expression de l'un a (dans les sens de base et étendu) une expression correspondante de l'autre. Ce sont deux notations pour les mêmes choses. Une expression de l'un ou l'autre peut être considérée comme "procédurale" en l'exécutant comme analysée ou normalisée et comme "déclarative" en l'exécutant autrement. Le mythe essaie de capturer l'idée qu'une expression RC n'est pas opérateur par opérateur comme une expression utilisant des opérateurs RA de base. Mais une expression RC le fait identifie son non évidente expression RA de la forme normale à l'aide d'opérateurs de base. Et c'est c'est opérateur par opérateur comme une expression RA incluant des opérateurs étendus.

(Le mythe peut être aidé à cause de l'histoire des mots. "L'algèbre moderne" a des expressions avec des opérateurs prenant et donnant des valeurs et peut être calculée. "Le calcul" aka analyse - différenciation et intégration - a des expressions décrivant des valeurs via des limites et des sommations infinies impossibles à calculer. Nous calculons d'autres manières, en général seulement en calculant des approximations.)

(Aussi, ironiquement: "Le calcul des prédicats" est considéré comme spécifiant les choses "déclarativement" sans égard à la façon dont elles peuvent être calculées ou estimées autrement. Mais la sémantique/signification standard d'une telle expression est donnée en suivant un algorithme qui parcourt l'expression Il a donc une interprétation "procédurale" évidente.)

Amee · Answer

allez sur ce lien pour plus de détails. http://ecomputernotes.com/database-system/rdbms/relational-algebra-and-relational-calculus

[

PeterSon · Answer

Cette présentation d'une classe de NYU m'a été très utile. J'apprends juste cela aussi, donc je ne peux pas être trop utile, mais je sais au moins que l'algèbre relationnelle traite d'expressions d'ensemble plus spécifiques, d'opérations de jointure et de combinaisons d'ensemble tandis que le calcul relationnel s'en tient principalement aux relations ET-OU et soit les quantificateurs existentiels ("Il existe un x tel que [condition (x)]) ou universel (" Pour tous les x, [condition (x)]). J'imagine que les expressions algébriques relationnelles sont similaires à un langage d'assemblage en termes de fonctionnalité et de spécificité tandis que les expressions de calcul relationnel sont plus proches d'un langage de programmation de haut niveau, en apparence et en fonctionnalité. J'espère que cela aide certains.

user5076313 · Answer

Différence entre l'algèbre relationnelle et le calcul relationnel

Les opérations d'algèbre relationnelle manipulent certaines relations et fournissent une expression sous la forme de requêtes où, en tant que calcul relationnel, des requêtes sont formées sur la base de paires d'expressions.
RA a un opérateur comme jointure, union, intersection, division, différence, projection, sélection, etc. où RC a des tuples et des expressions orientées domaine.
RA est un langage procédural alors que RC est un système de requête non procédural.
La puissance expressive de RA et RC est équivalente. Cela signifie que toute requête qui pourrait être exprimée en RA pourrait être exprimée par une formule en RC.
Toute formule KC est traduite en requête algébrique.
Il y a une modification qui est facile dans les requêtes dans RA que dans RC.
RA a formé la forme mathématique et n'a pas de langage Juer1 spécifique. RC a également une forme mathématique mais a un langage de requête QUEL.
L'algèbre relationnelle est plus facile à manipuler et à comprendre que la RC.
Les requêtes RA sont plus puissantes que le RC.
Les RC sont des WFF formés où RA ne forme aucune formule.
RA est une procédure. Cela signifie que nous avons écrit certaines conditions dans l'ordre.
RC est un non procédural. Ici, nous avons écrit les conditions dans n'importe quel ordre.

Exemple:-

Exemple de bibliothèque: -

Book is a relation it have a following attributes. 1. Book Name 2. Accession Number 3. Year of publication

Problème:-

 Find out the all book names published in the year 2000

Algèbre relationnelle: -

 ------------------------------------------------------- | (σ (book) ) | | ¶ (yr_pub=2000) | | (Book name) | ------------------------------------------------------

Calcul relationnel: -

 S = { t | ∃ u ∈ book (t[book name] = u[book name]) ∧ (u[yr_pub] = 2000 ) }

Dans ce calcul relationnel, nous pouvons écrire la condition dans n'importe quel endroit comme ci-dessous.

 S = { t | ∃ u ∈ book (u[yr_pub] = 2000 ) ∧ (t[book name] = u[book name]) }

Mais en algèbre relationnelle, il faut d'abord trouver quels sont les tuples dont l'année de publication est 2000, ensuite il suffit d'extraire la colonne du nom du livre.