<<2022050601230>> Pentru cerința [ROCK132101]:

Care sunt albumele formației `Beatles` care s-au vândut în 2010 și 2011, dar nu și în 2015?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1003413]:

select titlu_album
  from formatii f inner join discografie d on f.id_formatie=d.id_formatie
  inner join vanzari_discuri v on d.id_album=v.id_album
  where case when (v.an='2010') and den_formatie='Beatles' then true else false end
  intersect
 select titlu_album
  from formatii f inner join discografie d on f.id_formatie=d.id_formatie
  inner join vanzari_discuri v on d.id_album=v.id_album
  where case when (v.an='2011') and den_formatie='Beatles' then true else false end
  except
   select titlu_album
  from formatii f inner join discografie d on f.id_formatie=d.id_formatie
  inner join vanzari_discuri v on d.id_album=v.id_album
  where case when (v.an='2015') and den_formatie='Beatles' then true else false end

și în tidyverse [1003422]:

setdiff(
     intersect(
          formatii %>%
               filter(den_formatie == 'Beatles') %>%
               inner_join(discografie) %>%
               select (id_album, titlu_album) %>%
               inner_join(vanzari_discuri) %>%
               filter (an == 2010) %>%
               select (id_album, titlu_album),
          formatii %>%
               filter(den_formatie == 'Beatles') %>%
               inner_join(discografie) %>%
               select (id_album, titlu_album) %>%
               inner_join(vanzari_discuri) %>%
               filter (an == 2011) %>%
               select (id_album, titlu_album)
     ), 
          formatii %>%
               filter(den_formatie == 'Beatles') %>%
               inner_join(discografie) %>%
               select (id_album, titlu_album) %>%
               inner_join(vanzari_discuri) %>%
               filter (an == 2015) %>%
               select (id_album, titlu_album)
)

Care vi se pare mai ușor de înțeles?

Select one:
a. Nici SQL, nici tidyverse
b. Categoric, SQL!
c. Mai degrabă SQL
d. Și SQL, și tidyverse (în aproximativ egală măsură)
e. Mai degrabă tidyverse
f. Categoric, tidyverse!

<<2022050601230>> Pentru cerința [ROCK132101]:

Care sunt albumele formației `Beatles` care s-au vândut în 2010 și 2011, dar nu și în 2015?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1003413]:

select titlu_album
  from formatii f inner join discografie d on f.id_formatie=d.id_formatie
  inner join vanzari_discuri v on d.id_album=v.id_album
  where case when (v.an='2010') and den_formatie='Beatles' then true else false end
  intersect
 select titlu_album
  from formatii f inner join discografie d on f.id_formatie=d.id_formatie
  inner join vanzari_discuri v on d.id_album=v.id_album
  where case when (v.an='2011') and den_formatie='Beatles' then true else false end
  except
   select titlu_album
  from formatii f inner join discografie d on f.id_formatie=d.id_formatie
  inner join vanzari_discuri v on d.id_album=v.id_album
  where case when (v.an='2015') and den_formatie='Beatles' then true else false end

și în tidyverse [1003422]:

setdiff(
     intersect(
          formatii %>%
               filter(den_formatie == 'Beatles') %>%
               inner_join(discografie) %>%
               select (id_album, titlu_album) %>%
               inner_join(vanzari_discuri) %>%
               filter (an == 2010) %>%
               select (id_album, titlu_album),
          formatii %>%
               filter(den_formatie == 'Beatles') %>%
               inner_join(discografie) %>%
               select (id_album, titlu_album) %>%
               inner_join(vanzari_discuri) %>%
               filter (an == 2011) %>%
               select (id_album, titlu_album)
     ), 
          formatii %>%
               filter(den_formatie == 'Beatles') %>%
               inner_join(discografie) %>%
                select (id_album, titlu_album) %>%
               inner_join(vanzari_discuri) %>%
               filter (an == 2015) %>%
               select (id_album, titlu_album)
)

Care vi se pare mai ușor de înțeles?

Select one:
a. Nici SQL, nici tidyverse
b. Categoric, SQL!
c. Mai degrabă SQL
d. Și SQL, și tidyverse (în aproximativ egală măsură)
e. Mai degrabă tidyverse
f. Categoric, tidyverse!
<<2022050600138>> Pentru cerința [ROCK180101]:
Care sunt membrii formației `Yes` care au participat la realizarea/înregistrarea tuturor
albumelor acestei formații ?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1011815]:

with muzicieni_albume_yes as
(select concat(prenume_scena, ' ', nume_scena) as nume_muz, d.id_album
 from muzicieni m 
inner join realizare_disc r on m.id_persoana=r.id_muzician 
inner join discografie d on r.id_album=d.id_album
  inner join formatii f on d.id_formatie = f.id_formatie
where den_formatie='Yes'), 
muzicieni_yes as
(select distinct nume_muz
  from muzicieni_albume_yes),  
albume_yes as
(select distinct id_album
  from muzicieni_albume_yes),
produs_cartezian_muzicieni_albume_yes as
(select *
 from muzicieni_yes cross join albume_yes)
select nume_muz
from muzicieni_yes
except
select nume_muz
from produs_cartezian_muzicieni_albume_yes
where (nume_muz, id_album) not in 
(select nume_muz, id_album
 from muzicieni_albume_yes)
order by 1

și în tidyverse [1011811]:

formatii %>%
     filter(den_formatie == 'Yes') %>%
     inner_join(discografie) %>%
     select (id_album) %>%
     inner_join(realizare_disc) %>%
     inner_join(muzicieni, by = c("id_muzician" = "id_persoana")) %>%
     group_by(nume_muz = paste(prenume_scena, nume_scena)) %>%
     summarise (nr_albume = n()) %>%
     inner_join(
          formatii %>%
          filter(den_formatie == 'Yes') %>%
          inner_join(discografie) %>%
          summarise (nr_albume = n())          
     ) %>%
     select (nume_muz) %>%
     arrange(nume_muz)

<<2022050601168>> Pentru cerința [ROCK175101]:

Care sunt cele mai lungi trei albume ale formației `Beatles`? Atenție, albumele pot avea durate
egale!

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1011210]:

with 
albume_beatles as
(select titlu_album, sum(durata_sec) as durata_album
from discografie 
natural join formatii 
  natural join alcatuire_disc 
where den_formatie='Beatles' 
group by titlu_album), 
al_treilea_album_3_beatles as
(select durata_album from albume_beatles order by durata_album desc offset 2 limit 1)
select titlu_album, albume_beatles.durata_album
from albume_beatles inner join al_treilea_album_3_beatles 
on albume_beatles.durata_album >= al_treilea_album_3_beatles.durata_album 
order by 2 desc

și în tidyverse [1011217]:

formatii %>%
     filter(den_formatie == 'Beatles') %>%
     inner_join(discografie) %>%
     inner_join(alcatuire_disc) %>%
     group_by(titlu_album) %>%
     summarise(durata_album = sum(durata_sec)) %>%
     arrange(desc(durata_album)) %>%
     distinct(durata_album) %>%
     slice(1:3) %>%
     inner_join(
          alcatuire_disc %>%
               inner_join(discografie) %>%
               inner_join(formatii) %>%
               filter(den_formatie == 'Beatles') %>%
               group_by(titlu_album) %>%
               summarise(durata_album = sum(durata_sec))
     ) %>%
    select (titlu_album, durata_album)

Care vi se pare mai ușor de înțeles?

<<2022050600060>> Pentru cerința [ROCK121104]:

Care sunt membrii formației `Yes` care au participat la înregistrarea albumului `Going For The
One`?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1002314]:

select prenume_scena, nume_scena
from muzicieni m 
   inner join realizare_disc r on m.id_persoana=r.id_muzician 
   inner join discografie d on d.id_album=r.id_album inner join formatii f on f.id_formatie=d.id_f
ormatie 
where case den_formatie when 'Yes' then true else false end  and 
   titlu_album='Going For The One'

și în tidyverse [1002321]:

formatii %>%
     filter (den_formatie == 'Yes') %>%
     select(id_formatie) %>%
     inner_join(discografie) %>%
     filter (titlu_album == 'Going For The One') %>%
     inner_join(realizare_disc) %>%
     inner_join(muzicieni, by = c("id_muzician" = "id_persoana")) %>%
     select (prenume_scena, nume_scena)

<<2022050600847>> Pentru cerința [ROCK174102]:

Care este cel mai lung album (sau albume, dacă este cazul) al formației `Queen` ?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1010909]:

WITH albume_queen AS 
(SELECT titlu_album, SUM(durata_sec) AS durata_album
 FROM discografie d 
NATURAL JOIN formatii
  NATURAL JOIN alcatuire_disc 
 WHERE den_formatie='Queen'
 GROUP BY titlu_album), 
 queen_album_max AS (
  SELECT MAX(durata_album) AS durata_album FROM albume_queen)
SELECT albume_queen.*
FROM albume_queen NATURAL JOIN queen_album_max\

și în tidyverse [1010911]:

formatii %>%
     filter (den_formatie == 'Queen') %>%
     inner_join(discografie) %>%
     inner_join(alcatuire_disc) %>%
     group_by(titlu_album) %>%
     summarise(durata_album = sum(durata_sec)) %>%
     top_n(1, durata_album)

Care vi se pare mai ușor de înțeles?

<<2022050600254>> Pentru cerința [ROCK141102]:

Care este denumirea ultimei țări (în ordine alfabetică)?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1004518]:

select MAX(nume_tara)
from tari 
order by 1
limit 1

și în tidyverse [1004523]:

tari %>%
     select (nume_tara) %>%
     arrange(desc(nume_tara)) %>%
     head(1)

Care vi se pare mai ușor de înțeles?

<<2022050600399>> Pentru cerința [ROCK130101]:

Care sunt albumele la care au participat împreună `Jon Anderson` și `Rick Wakeman`?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1002415]:

select titlu_album 
from discografie d 
  natural join realizare_disc r 
  inner join muzicieni m on r.id_muzician=m.id_persoana 
where concat(prenume_scena,' ', nume_scena) ='Jon Anderson'
intersect
select titlu_album 
from discografie d 
  natural join realizare_disc r 
  inner join muzicieni m on r.id_muzician=m.id_persoana 
where concat(prenume_scena,' ', nume_scena) = 'Rick Wakeman'

și în tidyverse [1002424]:

muzicieni %>%
          inner_join(realizare_disc, by = c("id_persoana" = "id_muzician")) %>%
          inner_join(discografie) %>%
          filter(paste(prenume_scena, nume_scena) == 'Jon Anderson') %>%
          select (id_album, titlu_album) %>%
     inner_join(
               muzicieni %>%
                    inner_join(realizare_disc, by = c("id_persoana" = "id_muzician")) %>%
                    inner_join(discografie) %>%
                    filter(paste(prenume_scena, nume_scena) == 'Rick Wakeman') %>%
                    select (id_album, titlu_album))

Care sunt albumele formației `Beatles` lansate după

albumul `Help!`?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [2001108]:

SELECT discografie.* 
FROM discografie NATURAL JOIN formatii
WHERE den_formatie = 'Beatles' AND an_lansare || '-' || 
ordine_an > ALL
(SELECT an_lansare || '-' || ordine_an
 FROM discografie NATURAL JOIN formatii
 WHERE den_formatie = 'Beatles' AND titlu_album = 'He
lp!')
ORDER BY an_lansare, ordine_an

și în tidyverse [2001119]:
discografie %>%
    inner_join(
        formatii %>%
            filter (den_formatie == 'Beatles') %>%
            select (id_formatie)) %>%
    filter (titlu_album == 'Help!') %>%
    transmute(id_formatie, id_ordine_help = an_lansare * 
10 + ordine_an) %>%
    inner_join(discografie) %>%
    filter (an_lansare * 10 + ordine_an > id_ordine_help) 
%>%
    select (id_album, titlu_album, id_formatie, an_lansare:
coeficient_volum_vanzari) %>%
    arrange(an_lansare, ordine_an)

<<2022050600269>> Pentru cerința [ROCK140101]:

La câte albume a participat muzicianul `Steve Howe`?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1003911]:

select count(d.id_album) 
from discografie d 
  inner join realizare_disc r on d.id_album=r.id_album
  inner join muzicieni m on m.id_persoana=r.id_muzician
where concat(prenume_scena,' ', nume_scena)='Steve H
owe'

și în tidyverse [1003921]:
muzicieni %>%
     filter(paste(prenume_scena, nume_scena) == 'Steve 
Howe') %>%
     inner_join(realizare_disc, by = c("id_persoana" = "id_
muzician")) %>%
     inner_join(discografie) %>%
     summarise(n = n())
<<2022050600208>> Pentru cerința [ROCK170103]:
Care este ultima piesă de pe albumul `Help!` al formației
`Beatles`?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1009321]:

WITH
piese_help AS (
SELECT titlu_piesa, nr_ordine
FROM alcatuire_disc
       NATURAL JOIN discografie 
       NATURAL JOIN formatii 
     WHERE titlu_album='Help!' and den_formatie='Beatl
es'), 
ultima_piesa_help AS (
SELECT MAX(nr_ordine) AS nr_ordine
FROM piese_help
)
SELECT titlu_piesa
FROM piese_help NATURAL JOIN ultima_piesa_help

și în tidyverse [1009311]:
formatii %>%
     filter(den_formatie == 'Beatles') %>%
     inner_join(discografie) %>%
     filter (titlu_album == 'Help!') %>%
     inner_join(alcatuire_disc) %>%
     arrange (desc(nr_ordine)) %>%
     head(1) %>%
     select (titlu_piesa)

Care sunt muzicienii ale căror prim prenume real începe

cu secvența (literele) `Jo`?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1000814]:

select prenume_real, nume_real 
from muzicieni 
where case substr(prenume_real,1,2) when 'Jo' THEN TR
UE ELSE FALSE END

și în tidyverse [1000816]:

muzicieni %>% filter (if_else (str_detect(prenume_real, '
^Jo'), TRUE, FALSE)) %>%
     select (prenume_real, nume_real)

<<2022050601480>> Pentru cerința [ROCK171101]:

Care sunt primele trei albume lansate de formația
`Beatles`?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1009501]:

select titlu_album, an_lansare, ordine_an
from discografie d inner join formatii f on d.id_formatie
=f.id_formatie
where den_formatie='Beatles' 
order by an_lansare, ordine_an 
limit 3

și în tidyverse [1009508]:

formatii %>%
    filter(den_formatie == 'Beatles') %>%
    inner_join(discografie) %>%
    arrange(an_lansare, ordine_an) %>%
    head(3) %>%
    select (titlu_album, an_lansare, ordine_an)

Care vi se pare mai ușor de înțeles?

<<2022050600700>> Pentru cerința [ROCK120102]:

Care sunt albumele din anii '70 (1970-1979) ale
formației `Yes` ?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1001513]:

select titlu_album 
from discografie d inner join formatii f on d.id_formatie
=f.id_formatie 
where case when (an_lansare between 1970 and 1979) a
nd  den_formatie='Yes' then true else false end

și în tidyverse [1001524]:

formatii %>%
     filter (den_formatie == "Yes") %>%
     select (id_formatie) %>%
     inner_join(discografie %>%
                    filter (substr(an_lansare, 1, 3) == "197")) %>
%
     select (titlu_album, an_lansare)

Care vi se pare mai ușor de înțeles?

Marked out of 1.00
Flag question
Question text

<<2022050601328>> Pentru cerința [ROCK200101]:

Pentru fiecare formație, afișați, pe coloane separate,
vânzările formației pentru anii 1990, 1991, 1992, 1993 și
1994. În raport se vor include numai formațiile cu
vânzări în cel puțin unul dintre acești ani.

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1020002]:

SELECT den_formatie, 
ROUND(SUM (COALESCE(v1990.vanzari_usd,0)),2) AS va
nzari_1990,
ROUND(SUM (COALESCE(v1991.vanzari_usd,0)),2) AS va
nzari_1991,
ROUND(SUM (COALESCE(v1992.vanzari_usd,0)),2) AS va
nzari_1992,
ROUND(SUM (COALESCE(v1993.vanzari_usd,0)),2) AS va
nzari_1993,
ROUND(SUM (COALESCE(v1994.vanzari_usd,0)),2) AS va
nzari_1994
FROM formatii f
NATURAL JOIN discografie d
LEFT JOIN vanzari_discuri v1990 ON d.id_album = v1990
.id_album AND v1990.an = 1990
LEFT JOIN vanzari_discuri v1991 ON d.id_album = v1991
.id_album AND v1991.an = 1991
LEFT JOIN vanzari_discuri v1992 ON d.id_album = v1992
.id_album AND v1992.an = 1992
LEFT JOIN vanzari_discuri v1993 ON d.id_album = v1993
.id_album AND v1993.an = 1993
LEFT JOIN vanzari_discuri v1994 ON d.id_album = v1994
.id_album AND v1994.an = 1994
GROUP BY den_formatie
HAVING 
ROUND(SUM (COALESCE(v1990.vanzari_usd,0)),2) +
ROUND(SUM (COALESCE(v1991.vanzari_usd,0)),2) +
ROUND(SUM (COALESCE(v1992.vanzari_usd,0)),2) +
ROUND(SUM (COALESCE(v1993.vanzari_usd,0)),2) +
ROUND(SUM (COALESCE(v1994.vanzari_usd,0)),2) > 0
ORDER BY den_formatie

și în tidyverse [1020014]:
formatii %>%
     inner_join(discografie) %>%
     select(den_formatie, id_album) %>%
     inner_join(vanzari_discuri) %>%
     group_by(den_formatie) %>%
     summarise(
          vanzari_1990 = sum(if_else(an == 1990, coalesce(v
anzari_usd,0), 0)),
          vanzari_1991 = sum(if_else(an == 1991, coalesce(v
anzari_usd,0), 0)),
          vanzari_1992 = sum(if_else(an == 1992, coalesce(v
anzari_usd,0), 0)),
          vanzari_1993 = sum(if_else(an == 1993, coalesce(v
anzari_usd,0), 0)),
          vanzari_1994 = sum(if_else(an == 1994, coalesce(v
anzari_usd,0), 0))
     ) %>%
     filter(vanzari_1990 + vanzari_1991 + vanzari_1992 + 
vanzari_1993 + vanzari_1994 > 0) %>%
     arrange(den_formatie)

Care vi se pare mai ușor de înțeles?

<<2022050600716>> Pentru cerința [ROCK112104]:

În ce țări s-au înregistrat vânzări de discuri?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1001323]:
select distinct nume_tara
from vanzari_discuri natural join tari

și în tidyverse [1001315]:

vanzari_discuri %>% 
     inner_join(tari) %>%
     transmute (nume_tara) %>% 
     distinct(.)

Care vi se pare mai ușor de înțeles?

<<2022050601259>> Pentru cerința [ROCK150102]:

Afișați încasările din vânzarea discurilor în perioada
1991-2000, pe formații

se dau două soluții echivalente (ca rezultat),

scrise în SQL [2001205]:

select den_formatie, sum(vanzari_USD) as vanzari_USD
from vanzari_discuri 
natural join discografie 
natural join formatii 
where an between 1991 and 2000
group by den_formatie
order by den_formatie

și în tidyverse [2001211]:

vanzari_discuri %>%
     filter (an >= 1991 & an <= 2000 ) %>%
     select (-cod_tara) %>%
     inner_join(discografie) %>%
     inner_join(formatii) %>%
     group_by(den_formatie) %>%
     summarise (vanzari_usd = sum(vanzari_usd)) %>%
     arrange(den_formatie)

Care vi se pare mai ușor de înțeles?

<<2022050600992>> Pentru cerința [ROCK172102]:

Extrageți cei mai în vârstă (batrâni) trei membri ai
formației `Beatles` (este posibil ca doi sau mai mulți
muzicieni să fie născuți în aceeași zi)

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1010118]:

with 
membri_beatles as (
select distinct m.* 
from muzicieni m 
inner join realizare_disc r on m.id_persoana=r.id_muzicia
n
inner join discografie d on r.id_album=d.id_album
inner join formatii f on d.id_formatie=f.id_formatie
where f.den_formatie='Beatles'
),
trei_date as (
select data_nastere
from membri_beatles
order by data_nastere
limit 3
)
select membri_beatles.*
from membri_beatles natural join trei_date
order by data_nastere

și în tidyverse [1010110]:

formatii %>%
    filter (den_formatie == 'Beatles') %>%
    inner_join(discografie) %>%
    inner_join(realizare_disc) %>%
    transmute(id_persoana = id_muzician) %>%
    inner_join(muzicieni) %>%
    distinct(.) %>%
    filter (data_nastere %in% 
               (formatii %>%
                    filter (den_formatie == 'Beatles') %>%
                    inner_join(discografie) %>%
                    inner_join(realizare_disc) %>%
                    inner_join(muzicieni, by = c("id_muzician" = 
"id_persoana")) %>%
                    distinct (id_muzician, data_nastere) %>%
                    arrange (data_nastere) %>%
                    select (data_nastere) %>%
                    head(3)) [["data_nastere"]]  ) %>%
    arrange(data_nastere)

Care vi se pare mai ușor de înțeles?

<<2022050601587>> Pentru cerința [ROCK167101]:
Care sunt albumele la care au participat împreună `Jon
Anderson` și `Rick Wakeman`?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [2000710]:

select titlu_album from discografie 
where id_album in 
(select id_album from realizare_disc where id_muzician i
n 
  (select id_persoana from muzicieni
 where concat(prenume_scena,' ', nume_scena) = 'Jon A
nderson')
 intersect
 select id_album from realizare_disc where id_muzician i
n 
  (select id_persoana from muzicieni
 where concat(prenume_scena,' ', nume_scena) ='Rick W
akeman')
 )

și în tidyverse [2000716]:

muzicieni %>%
    filter(paste(prenume_scena, nume_scena) == 'Jon An
derson') %>%
    inner_join(realizare_disc, by = c('id_persoana' = 'id_m
uzician')) %>%
    select(id_album) %>%
    inner_join(realizare_disc) %>%
    inner_join(muzicieni, by = c('id_muzician' = 'id_persoa
na')) %>%
    filter(paste(prenume_scena, nume_scena) == 'Rick W
akeman') %>%
    select (id_album) %>%
    inner_join(discografie) %>%
    distinct (titlu_album)

<<2022050600535>> Pentru cerința [ROCK110103]:

Care sunt muzicienii născuți înainte de anul 1960?

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1000313]:

SELECT * 
FROM muzicieni 
WHERE Data_Nastere < TO_DATE( '1960-01-01', 'YYYY-
MM-DD')

și în tidyverse [1000321]:

muzicieni %>% 
     filter (data_nastere < as.Date('1960-01-01'))

Care vi se pare mai ușor de înțeles?

<<2022050601307>> Pentru cerința [ROCK122101]:

Folosind autojoncțiunea, extrageți țările din aceeași
regiune geografică cu România

se dau două soluții echivalente (ca rezultat),

scrise în SQL [1006413]:

select a.nume_tara 
from tari a 
   inner join tari b on a.regiune=b.regiune
where case when b.nume_tara = 'Romania' then true els
e false end

și în tidyverse [1006421]:

tari %>%
     filter (nume_tara == 'Romania') %>%
     select (regiune) %>%
     inner_join(tari) %>%
     select (nume_tara) %>%
     arrange(nume_tara)

Care vi se pare mai ușor de înțeles?

tari %>%
     filter (nume_tara == 'Romania') %>%
     select (regiune) %>%
     inner_join(tari) %>%
     select (nume_tara) %>%
     arrange(nume_tara)

<<2022050601066>> Pentru cerința [ROCK173102]:

Care sunt albumele formației `Beatles` cu mai multe
piese decât albumul `Rubber Soul` ?
se dau două soluții echivalente (ca rezultat),
scrise în SQL [1010501]:

select titlu_album, count(titlu_piesa) 
from alcatuire_disc a 
inner join discografie d on a.id_album=d.id_album 
inner join formatii f on  d.id_formatie=f.id_formatie
where den_formatie='Beatles'
group by titlu_album
having count(titlu_piesa) > 
(select count(titlu_piesa) 
 from alcatuire_disc a 
  inner join discografie d on a.id_album=d.id_album
inner join formatii f on  d.id_formatie=f.id_formatie
where den_formatie='Beatles' and titlu_album='Rubber 
Soul')
order by 2 desc

și în tidyverse [1010512]:

formatii %>%
     filter (den_formatie == 'Beatles') %>%
     inner_join(discografie) %>%
     inner_join(alcatuire_disc) %>%
     group_by(titlu_album) %>%
     summarise (nr_piese = n()) %>%
     mutate (nr_piese_rs = if_else(titlu_album == 'Rubber 
Soul', nr_piese, 0L)) %>%
     mutate(nr_piese_rs_ok = max(nr_piese_rs)) %>%
     filter (nr_piese > nr_piese_rs_ok) %>%
     select (titlu_album, nr_piese) %>%
     arrange(desc(nr_piese))

Care vi se pare mai ușor de înțeles?