Combining two tables in a complex way - mysql

Question

The situation:
I have the main table, lets call it MainTable.
+---------+----------+----------+----------+
| Id (PK)| Title | Text | Type |
+---------+----------+----------+----------+
| 1 | Some Text|More Stuff| A |
| 2 | Another | Example | B |
+---------+----------+----------+----------+
And I have a second table called TranslationsTable, in which the Id field is the representation of the MainTable row Id (no foreign key, as it can be refering to different tables), The ObjType is the ObjectType (same name as table), the FieldName is the name of the field from the ObjecType and the value has the translation value for the FieldName value in the ObjType table.
+---------+-----------+-----------+------------+----------+
| Id | ObjType | FieldName | Value | Language |
+---------+-----------+-----------+------------+----------+
| 1 | MainTable | Title | Algum Texto| PT |
| 1 | MainTable | Text | Mais Coisas| PT |
+---------+-----------+-----------+------------+----------+
And because I need to search in translated fields, I figured I could use a TEMPORARY TABLE to do so, but then came the problem of "Which SELECT query should I use?". I read some posts about pivot table queries, but I don't really know how can I build a query so my temp table is something like
+---------+------------+------------+----------+
| Id (PK)| Field_1 | Field_2 | Field_3 |
+---------+------------+------------+----------+
| 1 | Algum Texto| Mais Coisas| A |
+---------+------------+------------+----------+
Thank you.
EDIT:
I accepted AD7six answer because for 500.000 entries in the MainTable and 1.500.000 in the Translations it is roughly 30x times faster than the other one.

Answer 1

SELECT
orig.Id,
COALESCE(xlate.Field_1, orig.Field_1) AS Field_1,
COALESCE(xlate.Field_2, orig.Field_2) AS Field_2,
COALESCE(xlate.Field_3, orig.Field_3) AS Field_3
FROM MainTable orig
INNER JOIN (
SELECT
Id,Field_1,Field_2,Field_3
FROM TranslationsTable
PIVOT(MIN(Value) FOR FieldName IN (Field_1,Field_2,Field_3)) p
WHERE ObjType = 'MainTable'
) xlate ON (orig.Id = xlate.Id)
If you want to include the (untranslated) rows from MainTable that have no matches in TranslationsTable, change the INNER JOIN to LEFT OUTER JOIN
Another alternative is to perform the pivot manually:
SELECT
orig.Id,
COALESCE(xlate.Field_1, orig.Field_1) AS Field_1,
COALESCE(xlate.Field_2, orig.Field_2) AS Field_2,
COALESCE(xlate.Field_3, orig.Field_3) AS Field_3
FROM MainTable orig
INNER JOIN (
SELECT
Id,
MIN(CASE FieldName WHEN 'Field_1' THEN Value END) AS Field_1,
MIN(CASE FieldName WHEN 'Field_2' THEN Value END) AS Field_2,
MIN(CASE FieldName WHEN 'Field_3' THEN Value END) AS Field_3
FROM TranslationsTable
WHERE ObjType = 'MainTable'
GROUP BY Id
) xlate ON (orig.Id = xlate.Id)
With a change in the MainTable schema like others have suggested, you won't need the repetition for (Field_1,Field_2,Field_3). It makes the code easier to maintain and modify.

Answer 2

That's not complex
It's just a query with one join per translated field.
That means you query/sort/whatever it like any other e.g. (Using some real names so that it's easier to read):
SELECT
products.id,
COALESCE(product_name.value, products.name) as name,
COALESCE(product_description.value, products.description) as description
FROM
products
LEFT JOIN
TranslationsTable AS product_name
ON (
product_name.Language = 'PT' AND
product_name.ObjectType = 'products' AND
product_name.FieldName = 'name' AND
product_name.id = products.id
)
LEFT JOIN
TranslationsTable AS product_description
ON (
product_description.Language = 'PT' AND
product_description.ObjectType = 'products' AND
product_description.FieldName = 'description' AND
product_description.id = products.id
)
WHERE
product_name.value = "Algum Texto" // Find all products named "Algum Texto"
You don't need a temp table
But if you want to create one, it's easy to do using the query itself:
CREATE TABLE
products_pt
AS
SELECT
products.id,
COALESCE(product_name.value, products.name) as name,
COALESCE(product_description.value, products.description) as description
...
This will create a table (no indexes) matching the structure of the query. If your data does not change frequently it can make querying your multilingual data a lot easier to manage, but has some disadvantages such as (obviously) your translation-specific table will not be up to date if the source table data changes.