mysql - una - utilizar indices en consultas sql

cómo usar un me gusta con un join en sql?

Question

Tengo 2 tablas, digamos la tabla A y la tabla B y quiero realizar una unión, pero la condición coincidente tiene que ser donde una columna de A ''es como'' una columna de B, lo que significa que cualquier cosa puede venir antes o después de la columna SEGUNDO:

por ejemplo: si la columna en A es ''foo''. Entonces la unión coincidiría si la columna en B es: ''fooblah'', ''somethingfooblah'', o simplemente ''foo''. Sé cómo usar los comodines en una declaración estándar similar, pero estoy confundido al hacer una unión. ¿Esto tiene sentido? Gracias.

Answer 1

El uso de criterios condicionales en una unión es definitivamente diferente de la cláusula Where. La cardinalidad entre las tablas puede crear diferencias entre las cláusulas Join y Where.

Por ejemplo, el uso de una condición similar en una unión externa mantendrá todos los registros en la primera tabla enumerada en la unión. Usar la misma condición en la cláusula Where cambiará implícitamente la unión a una unión interna. El registro generalmente debe estar presente en ambas tablas para lograr la comparación condicional en la cláusula Where.

Generalmente uso el estilo dado en una de las respuestas anteriores.

tbl_A as ta
    LEFT OUTER JOIN tbl_B AS tb
            ON ta.[Desc] LIKE ''%'' + tb.[Desc] + ''%''

De esta forma puedo controlar el tipo de unión.

Answer 2

En MySQL puedes probar:

SELECT * FROM A INNER JOIN B ON B.MYCOL LIKE CONCAT(''%'', A.MYCOL, ''%'');

Por supuesto, esta sería una consulta enormemente ineficiente porque haría un escaneo completo de la tabla.

Actualización: Aquí hay una prueba

create table A (MYCOL varchar(255));
create table B (MYCOL varchar(255));
insert into A (MYCOL) values (''foo''), (''bar''), (''baz'');
insert into B (MYCOL) values (''fooblah''), (''somethingfooblah''), (''foo'');
insert into B (MYCOL) values (''barblah''), (''somethingbarblah''), (''bar'');
SELECT * FROM A INNER JOIN B ON B.MYCOL LIKE CONCAT(''%'', A.MYCOL, ''%'');
+-------+------------------+
| MYCOL | MYCOL            |
+-------+------------------+
| foo   | fooblah          |
| foo   | somethingfooblah |
| foo   | foo              |
| bar   | barblah          |
| bar   | somethingbarblah |
| bar   | bar              |
+-------+------------------+
6 rows in set (0.38 sec)

Answer 3

Si esto es algo que tendrá que hacer a menudo ... entonces es posible que desee desnormalizar la relación entre las tablas A y B.

Por ejemplo, al insertar en la tabla B, podría escribir cero o más entradas en una tabla de unión que mapee B a A en función de la asignación parcial. Del mismo modo, los cambios en cualquiera de las tablas podrían actualizar esta asociación.

Todo esto depende de con qué frecuencia se modifiquen las tablas A y B. Si son bastante estáticos, entonces recibir un golpe en INSERT es menos doloroso que los golpes repetidos en SELECT.

Answer 4

Usando INSTR :

SELECT *
  FROM TABLE a
  JOIN TABLE b ON INSTR(b.column, a.column) > 0

Usando LIKE:

SELECT *
  FROM TABLE a
  JOIN TABLE b ON b.column LIKE ''%''+ a.column +''%''

Usando LIKE, con CONCAT:

SELECT *
  FROM TABLE a
  JOIN TABLE b ON b.column LIKE CONCAT(''%'', a.column ,''%'')

Tenga en cuenta que en todas las opciones, es probable que desee conducir los valores de columna a mayúsculas ANTES de comparar para asegurarse de obtener las coincidencias sin preocuparse por la distinción entre mayúsculas y minúsculas:

SELECT *
  FROM (SELECT UPPER(a.column) ''ua''
         TABLE a) a
  JOIN (SELECT UPPER(b.column) ''ub''
         TABLE b) b ON INSTR(b.ub, a.ua) > 0

El más eficiente dependerá finalmente de la salida del plan EXPLAIN .

JOIN cláusulas JOIN son idénticas a las cláusulas WHERE escritura. La sintaxis JOIN también se conoce como uniones ANSI porque estaban estandarizadas. Las UNIONES ANSI no ANSI se ven así:

SELECT *
  FROM TABLE a,
       TABLE b
 WHERE INSTR(b.column, a.column) > 0

No voy a molestarme con un ejemplo de UNIÓN IZQUIERDA No ANSI. El beneficio de la sintaxis de ANSI JOIN es que separa lo que está uniendo las tablas de lo que está sucediendo realmente en la cláusula WHERE .