“ambigu nom de la colonne” en SQLite INNER JOIN

J'ai deux tables dans une DB SQLite, INVITEM et SHOPITEM. Leurs partagé attribut est ItemId et je veux effectuer une JOINTURE INTERNE. Voici la requête:

    SELECT  INVITEM.CharId AS CharId, 
            INVITEM.ItemId AS ItemId 
      FROM  (INVITEM as INVITEM 
INNER JOIN  SHOPITEM AS SHOPITEM 
        ON  SHOPITEM.ItemId = INVITEM.ItemId)
     WHERE  ItemId = 3;

SQLite ne l'aime pas :

SQL error: ambiguous column name: ItemId

L'erreur disparaît si j'écris WHERE INVITEM.ItemId = 3, mais depuis que la condition est plus ou moins spécifié par l'utilisateur, je préfère le faire fonctionner sans avoir à spécifier la table. JOINTURE NATURELLE semble résoudre le problème, mais je ne sais pas si la solution est assez générale (c'est à dire que je pourrais utiliser dans ce cas, mais je ne suis pas sûr si je peux l'utiliser dans tous les cas)

Toute autre syntaxe SQL qui peut résoudre le problème?

OriginalL'auteur ggambett | 2009-02-17

  1. 0

    Je orienter clairement de permettre à l'utilisateur d'écrire des clauses SQL directement. C'est la source de vulnérabilités d'Injection SQL.

    Si vous avez besoin de la requête pour être flexible, d'essayer d'analyser l'entrée de l'utilisateur et de l'ajout de la clause where appropriée.

    Voici un code C# pour montrer l'idée générale

    // from user input
string user_column = "ItemID";
string user_value = "3";

string sql = "SELECT INVITEM.CharId AS CharId, INVITEM.ItemId AS ItemId FROM (INVITEM as INVITEM INNER JOIN SHOPITEM AS SHOPITEM ON SHOPITEM.ItemId = INVITEM.ItemId) ";

if (user_column == "ItemID")
{
    // using Int32.Parse here to prevent rubbish like "0 OR 1=1; --" being entered.
    sql += string.Format("WHERE INVITEM.ItemID={0}",Int32.Parse(user_value));
}

    Évidemment, si vous faites affaire avec plus d'une clause, vous aurez à remplacer ET OÙ dans les alinéas suivants.

    J'ai fini par faire quelque chose comme cela. Je n'ai jamais permettre à l'utilisateur d'écrire de SQL directement, mais les OÙ les clauses sont construites à l'aide de l'expression des modèles. La qualification de l'noms de colonne en cas de besoin en était assez.

    OriginalL'auteur geofftnz

  2. 10

    Je voudrais écrire cette requête de cette façon:

    SELECT i.CharId AS CharId, i.ItemId AS ItemId 
FROM INVITEM as i INNER JOIN SHOPITEM AS s USING (ItemId)
WHERE i.ItemId = 3;

    Je suis en utilisant le USING (ItemId) syntaxe qui est juste une question de goût. C'est l'équivalent de ON (i.ItemID = s.ItemID).

    Mais j'ai résolu l'ambiguïté en se qualifiant i.ItemID dans le WHERE clause. Vous penseriez que c'est inutile, puisque la i.ItemID = s.ItemID. Ils sont tous les deux égaux par la commutativité, donc il n'y a pas d'ambiguïté sémantique. Mais apparemment, SQLite n'est pas assez intelligent pour le savoir.

    Je n'aime pas utiliser NATURAL JOIN. C'est l'équivalent d'une équi-jointure de chaque colonne qui existe dans les deux tableaux avec le même nom. Je n'aime pas utiliser ce parce que je n'en veux pas à comparer les colonnes que je ne veux pas que ça, tout simplement parce qu'ils ont le même nom.

    OriginalL'auteur Bill Karwin

  3. 0

    Il suffit de changer votre alias de colonne à quelque chose de similaire, mais unique (comme ITEM_ID).

    OriginalL'auteur dave-holm