Comando JOIN

Anexo los registros de la tabla transactions:

INSERT INTO transactions (book_id, client_id, type, finished) VALUES
	(12,34,'sell',1),
	(54,87,'lend',0),
	(3,14,'sell',1),
	(1,54,'sell',1),
	(12,81,'lend',1),
	(12,81,'sell',1),
	(87,29,'sell',1);

Resumen de la clase:

-- Listar todos los autores con ID entre 1 y 5 con los filtro mayor y menor igual
SELECT * FROM authors WHERE author_id > 0 AND author_id <= 5;

-- Listar todos los autores con ID entre 1 y 5 con el filtro BETWEEN
SELECT * FROM authors WHERE author_id BETWEEN 1 AND 5;

-- Listar los libros con filtro de author_id entre 1 y 5
SELECT book_id, author_id, title FROM books WHERE author_id BETWEEN 1 AND 5;

-- Listar nombre y titulo de libros mediante el JOIN de las tablas books y authors
SELECT b.book_id, a.name, a.author_id, b.title
FROM books AS b
JOIN authors AS a
  ON a.author_id = b.author_id
WHERE a.author_id BETWEEN 1 AND 5;

-- Listar transactions con detalle de nombre, titulo y tipo. Con los filtro genero = F y tipo = Vendido.
-- Haciendo join entre transactions, books y clients.
SELECT c.name, b.title, t.type
FROM transactions AS t
JOIN books AS b
  ON t.book_id = b.book_id
JOIN clients AS c
  ON t.client_id = c.client_id
WHERE c.gender = 'F'
  AND t.type = 'sell';

-- Listar transactions con detalle de nombre, titulo, autoor y tipo. Con los filtro genero = M y de tipo = Vendido y Devuelto.
-- Haciendo join entre transactions, books, clients y authors.
SELECT c.name, b.title, a.name, t.type
FROM transactions AS t
JOIN books AS b
  ON t.book_id = b.book_id
JOIN clients AS c
  ON t.client_id = c.client_id
JOIN authors AS a
  ON b.author_id = a.author_id
WHERE c.gender = 'M'
  AND t.type IN ('sell', 'lend');

Para las personas que no tengan datos en la tabla de trasactions, yo tuve que eliminar la tabla original (la que venía en el archivo, DROP TABLE), porque no tenía dentro del ENUM a ‘return’, así que la volví a crear, esto es una pregunta también, si existe otra manera de hacerlo con el UPDATE, agradezco que me digan cómo. Luego hice el INSERT yo mismo, con los datos que tenía el profesor, los dejo aquí por si les sirven.

INSERT INTO transactions(book_id, client_id, type, finished)
VALUES(12, 34, ‘sell’,1),
(54, 87, ‘lend’,0),
(3, 14, ‘sell’,1),
(1, 54, ‘sell’,1),
(12, 81, ‘lend’,1),
(12, 81, ‘returned’,1),
(87, 29, ‘sell’,1);

Script Tabla transactions:

INSERT INTO transactions(transaction_id,book_id,client_id,type,finished)
VALUES(1,12,34,‘sell’,1),
(2,54,87,‘lend’,0),
(3,3,14,‘sell’,1),
(4,1,54,‘sell’,1),
(5,12,81,‘lend’,1),
(6,12,81,‘return’,1),
(7,87,29,‘sell’,1);

Insertar datos en ‘transactions’:
INSERT INTO transactions (book_id, client_id, type, finished) VALUES
(12,34,‘sell’,1),
(54,87,‘lend’,0),
(3,14,‘sell’,1),
(1,54,‘sell’,1),
(12,81,‘lend’,1),
(12,81,‘return’,1),
(87,29,‘sell’,1);

Alguien lo noto?

data transactions

INSERT INTO transactions (book_id, client_id, type, finished) VALUES
(12,34,'sell',1),
(54,87,'lend',0),
(3,14,'sell',1),
(1,54,'sell',1),
(12,81,'lend',1),
(12,81,'sell',1),
(87,29,'sell',1);

El script no incluye trasacciones 😥

El usar los alias “ejemplo” books como b es en mi personal punto de vista mala práctica dado que si tienes demasiadas tablas a la hora de hacer los cruces se confunde mucho dado que me ha tocado revisar queries bastante largos y suelen poner el alias así mismo como en esta clase y es tedioso andar buscando a que tabla se le nombró así, es mejor una buena descripción. saludos.

Muy interesante llegar a este punto y darse cuenta de lo que la normalizacion de los datos nos permite hacer. Para todos aquellos que desean entender un poco mas sobre esto les recomiendo leer un poco sobre “las doce reglas de Codd” esto les dara una vision clara de como funciona todo esto.

14- Comando JOIN

1. El corazón de una bases de datos relacional son las relaciones entre tablas.

2. SELECT count() FROM authors; count() nos devuelve el número de resultados de una sentencia SELECT.

3. SELECT * FROM authors WHERE author_id > 0 AND author_id<= 5; la palabra reservada AND nos permite anidar condiciones o sentencias.

4. SELECT * FROM books WHERE author_id BETWEEN 1 and 5; la palabra reservada BETWEEN nos ayuda a crear rangos.
   La sentencia JOIN sirve para realizar cruce de tablas, es decir permite juntar datos de distintas tablas y mostrarlas en un tabla temporal (SELECT) con la finalidad de aportar información puntual, legible y autentica.

5. SELECT b.book_id, b.title, a.name, a.author_id FROM authors AS a JOIN books AS b ON a.author_id=b.author_id WHERE a.author_id between 1 AND 30 ; La palabra reservada ON Ayuda al JOIN relacionar y condicionar las búsquedas de un SELECT-JOIN.

6. Se puede utilizar varios JOIN en una misma sentencia e incluso uno de los JOIN puede utilizar como tabla pivote que este en un JOIN anterior a esta.SELECT * FROM transactions WHERE t.type=IN(‘sell’,‘lend’); la Función lo que permites es acotar búsquedas de palabras especifica.

Para los que copiaron la creación de la tabla ‘transactions’ de la imagen que dejó el profesor, les dejo la sentencia para modificarla y agregarle la opción de ‘return’ en el campo type:

alter table transactions MODIFY type enum('lend','sell','return') NOT NULL;

además les dejo los datos que se ingresan:

INSERT INTO transactions(book_id, client_id, type, finished)
VALUES(12, 34,'sell', 1),
(54, 87, 'lend', 0),
(3, 14, 'sell', 1),
(1, 54, 'sell', 1),
(12, 81, 'lend', 1),
(12, 81, 'return', 1),
(87, 29, 'sell', 1)
;

Vengo desde fundamentos de bases de datos, y va quedando más claro el uso de join

Contextualizado el aporte del compañero @ecedenyo

SELECT c.name AS 'Cliente', b.title AS 'Titulo Libro', a.name as 'Autor', t.type AS 'Tipo de Transacción'
FROM transactions AS t
JOIN books as b
USING(book_id)
JOIN clients as c
USING(client_id)
JOIN authors as a
USING(author_id)
WHERE
c.gender = 'F'
AND
t.type = 'sell';

Excelente curso tan solo un aporte, las columnas también puede tener un ALIAS.
Por Ejemplo en la última consulta seleccionamos las siguientes columnas

SELECT c.name, b.title, a.name, t.type

y el resultado serán dos columnas con el campo name donde no sabemos si es el nombre del cliente o el nombre del autor. Para ello podemos resolver de la forma:

SELECT c.name AS client_name, b.title, a.name AS author_name, t.type

Espero les sirva de ayuda

Cuando las dos columnas que se van a usar para el JOIN tiene nombres iguales, se puede usar USING, en lugar de ON x = y.

me causa un poco de conflicto que se pueda usar C.name, b.tittle, t.type antes de la declaracion “…as t, as b, as c” jaja XD

Los JOIN son lo más bonito de la BASE DE DATOS. Imagínate navegar de un país a otro “sin restricciones” (con relaciones). Algo así lo veo yo. 😄

Resumen de la Clase:
Contenido:

• Relaciones entre tablas son el corazon de las bases de datos relacionales.
• JOIN = Inner Join

Funciones:

• count(*): cuenta todo

• 0 <= 5 es igual a between 1 and 5

• Join: tomar dos tablas, relacionarlas y mostrar la información ya relacionada.
• IN(): filtrar varias opciones

Tips:

• en un FROM puedo usar AS para facilitar escritura (Ej: FROM books AS b)

Código Clase:

--Clase 14 Comando Join

SELECT count(*) FROM books;
SELECT * FROM authors WHERE author_id > 0 and author_id <= 5;
SELECT * FROM authors WHERE author_id between 1 and 5;
SELECT book_id, author_id, title FROM books WHERE author_id between 1 and 5;
SELECT b.book_id, a.name, b.title
FROM books AS b
JOIN authors AS a
    on a.author_id = b.author_id
WHERE a.author_id between 1 and 5;
SELECT b.book_id, a.name, a.author_id, b.title
FROM books AS b
JOIN authors AS a
    on a.author_id = b.author_id
WHERE a.author_id between 1 and 5;
SELECT name FROM authors WHERE author_id = 4;

-- No tenia los datos de transactions, se agregan
INSERT INTO transactions (book_id, client_id, type, finished) VALUES
(12,34,'sell',1),
(54,87,'lend',0),
(3,14,'sell',1),
(1,54,'sell',1),
(12,81,'lend',1),
(12,81,'sell',1),
(87,29,'sell',1);

-- query de transactions
SELECT c.name, b.title, t.type
FROM transactions as t
join books as b
    on t.book_id = b.book_id
join clients as c
    on t.client_id = c.client_id

-- con condiciones
SELECT c.name, b.title, t.type
FROM transactions as t
join books as b
    on t.book_id = b.book_id
join clients as c
    on t.client_id = c.client_id
WHERE c.gender ='F'
    and t.type = 'sell';

-- cuarto join
SELECT c.name, b.title, t.type, a.name
FROM transactions as t
join books as b
    on t.book_id = b.book_id
join clients as c
    on t.client_id = c.client_id
join authors as a
    on b.author_id = a.author_id
WHERE c.gender ='F'
    and t.type = 'sell';

-- Cambios
SELECT c.name, b.title, t.type, a.name
FROM transactions as t
join books as b
    on t.book_id = b.book_id
join clients as c
    on t.client_id = c.client_id
join authors as a
    on b.author_id = a.author_id
WHERE c.gender ='M'
    and t.type IN ('sell', 'lend');

La información es poder.

Welfare = bienestar… Seguro es un libro de microeconomía.

Creo que la consulta para saber si el autor 4 había escrito o no un libro es la siguiente:
SELECT title
FROM books
WHERE author_id=4;

Porque el query del vídeo del profesor solo muestra el nombre del autor, si se le pone “5”, muestra el nombre de Juan Rulfo aunque si tenga publicaciones. 😉

Les dejo este site para generar data aleatoria en el caso que quieran jugar con tablas con mucha data: https://www.generatedata.com/

Hey, hola si tienen dudas acerca de esto, escribí un tutorial explicando un JOIN de forma sencilla con un ejemplo de la clase, aqui el link 😄;
https://platzi.com/tutoriales/1272-sql-mysql/20158-entendiendo-y-desestructurando-un-join/

This is my SQL query:

SELECT c.name AS 'client name', b.title AS 'book title', a.name AS 'author name', t.type AS 'transaction type'
FROM transactions as t
JOIN books as b
	ON t.book_id = b.book_id
JOIN clients as c
	ON t.client_id = c.client_id
JOIN authors as a
	ON b.author_id = a.author_id
WHERE c.gender = 'F'
	AND t.type IN ('sell', 'lend')
;

El código no tiene información en TRANSACTIONS:

INSERT INTO transactions(transaction_id, book_id, client_id, type, finished)
VALUES
(1, 12, 34, ‘sell’, 1),
(2, 54, 87, ‘lend’, 0),
(3, 3, 14, ‘sell’, 1),
(4, 1, 54, ‘sell’, 1),
(5, 12, 81, ‘lend’, 1),
(6, 12, 81, 'return’,1),
(7, 87, 29, ‘sell’, 1);

y el código tampoco tiene 'return ', hay que modificar type y agregarlo.

Los Joins es tomar dos tablas que al relacionarlas y desplegar esa información ya relacionada.
SELECT b.book_id, a.name, a.author_id, b.title
FROM books as b
JOIN authors as a
On a.author_id = b.author_id
WHERE a.author_id between 1 AND 5

ALTER TABLE transactions modify type enum(“lend”, “sell”, “return”) NOT NULL;
.
INSERT INTO transactions (transaction_id,book_id,client_id,type,finished)
VALUES (1,12,34,”sell”,1),
(2,54,87,”lend”,0),
(3,3,14,”sell”,1),
(4,1,54,”sell”,1),
(5,12,81,”lend”,1),
(6,12,81,”return”,1),
(7,87,29,”sell”,1);
SELECT c.name, b.title, a.name, t.type
FROM transactions AS t
JOIN books AS b
On t.book_id = b.book_id
JOIN clients AS c
On t.client_id = c.client_id
JOIN authors AS a
ON b.author_id = a.author_id
WHERE c.gender = “M”
AND t.type IN (“sell”, “lend”);

salgan corriendo jajaja
cuando dice que se espantan =(

reinciar la cuenta de transaction_id

alter table nombre_de_la_tabla AUTO_INCREMENT=1;

No me queda claro cual es la definición o concepto de “tabla pivote”, me podrian ayudar con una explicación mas pragmática

• Una tabla temporal.
• Una tabla (books) inicial a la cual se le agregan datos en su formato de visualización.
• Es la tabla (unión ) que se crea a partir de otras dos tablas.

Hice una ligera modificación, nada más para mejorar la lectura de las comunas.

SELECT c.name, b.title, a.name AS 'Author',  t.type 
    FROM  transactions as t
    join books as b
      on t.book_id = b.book_id
    join clients as c
      on t.client_id = c.client_id
    join authors as a
      on b.author_id = a.author_id
    WHERE c.gender = 'M'
      AND t.type IN ('sell', 'lend');

Justo en donde estoy trabajando utilizan mucho en su base de datos inner join

Jugando un poco

¡Pedazo de curso, Alberto Alcocer! (Y Platzi). Muy muy bueno, de los mejores que les he visto en general.

Simplemente genial.

Alguien tiene los datos de las transacciones?

Convencion over Configuration es un paradigma de programación de software que busca minimizar el número de decisiones que un desarrollador necesita hacer. Por ejemplo, si hay una clase «venta» en el modelo, por convención la tabla en la base de datos se llamará «ventas».

En el SQL de la sección de archivos está todo excepto inserts para la tabla transactions 😦

Acá otro ejemplo como en el curso de GIT de Fredy donde ocupan la consola con la fuente muy pequeña. Deberían ocupar una fuente gigante para poder ver correctamente los comandos. Igual ese fondo con negro se ve bien en la película matrix pero en una clase se nota de mal gusto. Tienen a muchos genios de diseño que podrían ayudarles 🤙

Excelente clase

Algo que se puede añadir es el uso de tablas temporales que contengan el resultado de un join, para que luego este resultado se le aplique un segundo join de ser necesario, ya que aplicar mas de un join en una sola consulta puede requerir demasiados recursos.

Las clases cada vez se colocan muy interesantes

SELECT T.transaction_id Num_Transaccion, B.title Titulo, B.year Ano, A.name Autor, C.name Nombre, 
C.email Correo, T.type Status
FROM transactions T
INNER JOIN books B
ON B.book_id = T.book_id
INNER JOIN authors A
ON A.author_id = B.author_id
INNER JOIN clients C
ON C.client_id = T.client_id
WHERE C.gender = 'M';```

Me encanta aprender bd, este curso vale oro

Severo spam en la base de datos jaja. Por un momento quede wtf no tengo lo mismo que el video. Despues de analizar el documento que crea la base de datos cai en cuenta de la genialidad que hicieron… Promocionando libros nivel dios 🤯 Se ganaron mis respetos

código de los inner joins:

select count(*) from books;
select count(*) from authors;

select * from authors where author_id > 0 and author_id <= 5;

select `book_id`, `author_id`, `title` from books where author_id between 1 and 5;

select books.book_id, authors.name, books.title, authors.author_id
from books
inner join authors
    on authors.author_id = books.author_id
where authors.author_id between 1 and 5;

select `name` from authors where `author_id` = 4;

select clients.name, books.title, transactions.type
from transactions
inner join books
    on transactions.book_id = books.book_id
inner join clients
    on transactions.client_id = clients.client_id
;

select clients.name, books.title, authors.name, transactions.type
from transactions
inner join books
    on transactions.book_id = books.book_id
inner join authors
    on books.author_id = authors.author_id
inner join clients
    on transactions.client_id = clients.client_id
where clients.gender = 'M' and transactions.type in ('sell', 'lend')
;

Se puede usar la siguiente query si se quiere actualizar un valor específico de una columna (en este caso type = sell
por type= lend)

UPDATE transactions SET type=‘lend’ WHERE transaction_id = 7 ;

Mi aporte con entradas más descriptivas

SELECT C.name AS client_name, B.title AS title_book, A.name AS author_name, T.type AS type_transactions
FROM transactions AS T
JOIN books as B 
ON T.book_id = B.book_id 
JOIN clients as C 
ON T.client_id = C.client_id
JOIN authors as A
ON B.author_id = A.author_id
WHERE C.gender = 'M'
AND T.type IN ('sell', 'lend');

-- saber cuantos datos tiene la tabla
select count(*) from books;
-- saber cuantos datos hay en autores
select count(*) from authors;
 -- trabajo con autores del 1 al 5
 select * from authors where author_id > 0 and author_id <=5;
 -- libros de los primeros 5 autores
select * from books where author_id between 1 and 5;
select book_id, author_id, title from books where author_id between 1 and 5;
  -- cruzando tablas
select b.book_id, a.name, b.title
from books as b
inner join authors as a
on a.author_id = b.author_id
where a.author_id between 1 and 5;
-- transctions
select c.name, b.title, t.type
from transactions as t
join books as b
on t.book_id = b.book_id
join clients as c
on t.client_id = c.client_id
join authors as a
on b.author_id = a.author_id
where c.gender = 'M'
and t.type IN ('sell', 'lend');

select c.client_id,c.name, a.name, b.title,t.type
from transactions as t 
inner join books as b
on t.book_id = b.book_id
join clients as c
on t.client_id = c.client_id 
join authors as a 
on b.author_id = a.author_id
where c.gender = 'M' and t.type in('sell','lend');

Tengo demsaidas dudas, de los temas mas dificiles con los que me he encontrado, de verdad no me entra la logica. 😦

Para quienes crearon la tabla como operations y usaron B-borrowed, R-returned y S-Sold:

INSERT INTO operations (book_id, client_id, type, finished) 
VALUES (12, 34, 'S', 1),
(54, 87, 'B', 0),
(3, 14, 'S', 1),
(1, 54, 'S', 1),
(12, 81, 'B', 0),
(12, 81, 'R', 1),
(87, 29, 'S', 1);

Les hago un aporte que me sirvio mucho:

select <atributos>
from tabla1
inner join tabla 2
on tabla1.atributo_clave = tabla2.atributo_clave

– -- COMDANDO JOIN --------
– Es tomar dos tabls y relacionarlas –
– Puedes ver todas las combinaciones en la imagen de la carpeta

– Si queremos ver la cantidad de algo:

SELECT count(*) FROM books;

– Condicional mayoes y menores:

select * from authors

<code>

 where author_id > 0 and author_id <= 5;

– BETWEEN (entre):

select * from books where author_id between 1 and 5;

– Utilizamos JOINS –

SELECT b.book_id, a.name, b.title
    FROM books AS b -- AS son Alias.
    JOIN authors AS a-- JOIN o INNER JOIN. La menajera más práctica y el que más se utiliza
        ON a.author_id = b.author_id
    WHERE a.author_id BETWEEN 1 AND 5

El campo author_id es UNSIGNED, con solo la condición <= 5 dentro del WHERE funciona.

usamos el Join para integrar datos de varias tablas y obtener una información útil

Excelente clase!!!

Ahora todo tiene sentido!
Este query:

	SELECT c.name, b.title, a.name, t.type
	FROM transactions AS t
	JOIN books AS b 
	   ON t.book_id = b.book_id
	JOIN clients AS c
	   ON t.client_id = c.client_id
	JOIN authors AS a
	   ON b.author_id = a.author_id
WHERE c.gender = 'M' AND t.type in ('sell','lend');

Es igual a este:

	SELECT c.name, b.title, a.name, t.type
	FROM transactions AS t
	INNER JOIN books AS b 
	   ON t.book_id = b.book_id
	INNER JOIN clients AS c
	   ON t.client_id = c.client_id
	INNER JOIN authors AS a
	   ON b.author_id = a.author_id
WHERE c.gender = 'M' AND t.type in ('sell','lend');

y este a este otro:

	SELECT c.name, b.title, a.name, t.type
	FROM transactions  t , books b, clients c,  authors  a
	WHERE 
	    t.book_id = b.book_id AND
	    t.client_id = c.client_id AND
               b.author_id = a.author_id AND
	   c.gender = 'M' AND t.type in ('sell','lend');

En clase vimos que el orden de los campos que unen las tablas no importa, pero investigando un poco, es buena práctica poner primero el “primary key” y luego el “foreign key (fk)”, así:

SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers ON Orders.CustomerID=Customers.CustomerID;```

Pienso que sería bueno crear llaves foráneas sobre esos campos que tengan coincidencia para llevar más control sobre esos valores que luego se relacionarán. Lo digo porque solo podrán insertar los valores que ya existen en las otras tablas y ayuda un montón. La bronca está cuando desees borrar un autor y se borre el ID y pues dependiendo del tipo de borrado que le pongas (SET NULL, CASCADE) afectará en la otra tabla.

Buenas clases

interesante las consultas que se pueden hacer utilizando la función JOIN

SELECT c.name AS 'Cliente', b.title AS 'Titulo Libro', a.name as 'Autor', t.type AS 'Tipo de Transacción'
FROM transactions AS t
JOIN books as b
ON
t.book_id = b.book_id
JOIN clients as c
ON
t.client_id = c.client_id
JOIN authors as a
ON
b.author_id = a.author_id
WHERE
c.gender = 'F'
AND
t.type = 'sell';```

Se esta poniendo buena las consultas 😎

Muy Buena Clase sobre los Joins

excelente curso

excelente curso…

Con este comando puedo hacer las mismas querys que ligar las tablas con una foreign key?

SELECT 	b.book_id, a.name, a.author_id, b.title
FROM 	books AS b 
		JOIN authors AS a 
			  ON a.author_id = b.author_id
WHERE a.author_id BETWEEN 1 AND 5;

BETWEEN

Es importante dominar bien el uso del SELECT junto con el JOIN, hace tiempo un youtuber que es DA le hicieron una entrevista y una de las preguntas requería saber SQL de nivel alto. Dejo el link por si quieren ver: https://www.youtube.com/watch?v=MfP-P8EHGBo minuto 4:05

La cuestión de los alias para las tablas me confunde muchísimo, así que use los nombres de las tablas como tal, pensé que eran necesarios los alias para JOIN

SELECT books.book_id, authors.name AS "Author Name",authors.author_id, books.title AS "Name book"  FROM books JOIN authors ON books.author_id = authors.author_id WHERE books.author_id BETWEEN 1 AND 5;

SELECT t.transaction_id,c.name AS 'Cliente',b.title AS 'Libro', a.name AS 'Nombre de autor',b.price, b.book_id, t.type
FROM authors AS a
INNER JOIN books As b
		ON a.author_id = b.author_id
INNER JOIN transactions AS t
		ON b.book_id = t.book_id
INNER JOIN clients AS c
		ON c.client_id = t.client_id
LIMIT 5

Las cosa van quedando cada vez más claras ,muy buena clase.

Comprendido

SELECT b.book_id, a.name, b.title,a.author_id AS A_ID ,b.author_id AS B_ID  FROM books AS b  INNER JOIN authors AS a  on a.author_id = b.author_id  WHERE a.author_id BETWEEN 1 AND 5;

select b.book_id, a.name, b.title  
from books as b 
JOIN authors as a 
on a.author_id = b.author_id 
where a.author_id between 1 and 5;

Recuerden que en el campo type de nuestra transacción es un enum, que recibe 2 valores “Lend” y “Sell”, por lo tanto hay que realizar un update para agregarle el Return.

como hago para borrar pantalla en mariadb no me sirve el comando \c

Buenas Noches.
Al colocar esa sentencia me aparece ese error.
Alguien me puede ayudar por favor.

Gracias.

Tengo una duda.
Ejecuto la consulta

SELECT u.id_usuario, u.nombre_usuario, ru.rolusuario
FROM usuarios_rolesusuarios AS uru
JOIN usuarios AS u ON uru.id_usuario = u.id_usuario 
JOIN rolesusuarios AS ru ON uru.id_rolusuario = ru.id_rolusuario;

y no me aparece nada

la tabla “usuarios_rolesusuarios” Es una tabla intermedia donde relaciono los datos de los usuarios con su respectivo rol en el proyecto

la tabla de “usuarios” es donde tengo guardados usuarios

la tabla “rolesusuarios” es donde tengo guadados los roles de usuario de mi proyecto.

Tengo una duda
Alguna vez oí hablar de que hacer muchos joins hacían lentas las querys
¿Eso es cierto?
Por ejemplo yo estoy diseñando una base de datos compleja en la que los usuarios pertenecen a grupos y los grupos tienen otras características que necesitan tablas aparte y hacen que pueda necesitar hacer hasta 6 joins en una query para obtener información de todas las tablas.
Suena un poco exagerado pero no sé si estoy haciendo las cosas mal.

En mi experiencia al consultar una tabla con el comodín * para referirse a todas las columna contrae bastante tiempo, la mejor forma es especificar una columna.

Lo mismo se aplica a las funciones de integración como count(???)