Comment savoir si une table possède des colonnes uniques

- Je utiliser MS SQL Server.

Ive été remis dans les mains de quelques grandes tables avec des pas de limite, pas de touches rien.

Je sais que certaines colonnes ont des valeurs uniques. Est-il une façon intelligente pour une table donnée à la finde les cols qui ont des valeurs uniques ?

Droit maintenant, je le fais manuellement pour chaque colonne par comptage si il y a autant de valeurs DISTINCTES qu'il y a de lignes dans la table.

SELECT COUNT(DISTINCT col) FROM table

Pourrait prob faire un cusor en boucle sur toutes les colonnes, mais veulent entendre si quelqu'un en sait plus intelligents ou construire-dans la fonction.

Grâce.

source d'informationauteur zmaster

8

Ici est une approche qui est essentiellement similaire à @JNK mais au lieu de l'impression du compte, il renvoie une réponse pour chaque colonne que vous indique si une colonne est composée de valeurs uniques seulement ou pas:
```
DECLARE @table varchar(100), @sql varchar(max);
SET @table = 'some table name';

SELECT
  @sql = COALESCE(@sql + ', ', '') + ColumnExpression
FROM (
  SELECT
    ColumnExpression =
      'CASE COUNT(DISTINCT ' + COLUMN_NAME + ') ' +
      'WHEN COUNT(*) THEN ''UNIQUE'' ' +
      'ELSE '''' ' +
      'END AS ' + COLUMN_NAME
  FROM INFORMATION_SCHEMA.COLUMNS
  WHERE TABLE_NAME = @table
) s

SET @sql = 'SELECT ' + @sql + ' FROM ' + @table;
PRINT @sql;  /* in case you want to have a look at the resulting query */
EXEC(@sql);
```
Il compare simplement COUNT(DISTINCT column) avec COUNT(*) pour chaque colonne. Le résultat sera un tableau avec une ligne unique, où chaque colonne contient la valeur UNIQUE pour les colonnes qui n'ont pas de doublons, et la chaîne vide si des doublons sont présents.

Mais la solution ci-dessus ne peut fonctionner correctement que pour les colonnes qui n'ont pas de valeurs Null. Il convient de noter que SQL Server ne prend pas en ignorer les valeurs Null lorsque vous souhaitez créer une contrainte unique/index sur une colonne. Si une colonne contient une valeur NULL et toutes les autres valeurs sont uniques, vous pouvez toujours créer une contrainte unique sur la colonne (vous ne pouvez pas en faire une clé primaire, mais, ce qui nécessite à la fois uniquness des valeurs et de l'absence de valeurs Null).

Par conséquent, vous pourriez avoir besoin une analyse plus approfondie du contenu, ce qui vous pourriez obtenir avec le script suivant:
```
DECLARE @table varchar(100), @sql varchar(max);
SET @table = 'some table name';

SELECT
  @sql = COALESCE(@sql + ', ', '') + ColumnExpression
FROM (
  SELECT
    ColumnExpression =
      'CASE COUNT(DISTINCT ' + COLUMN_NAME + ') ' +
      'WHEN COUNT(*) THEN ''UNIQUE'' ' +
      'WHEN COUNT(*) - 1 THEN ' +
        'CASE COUNT(DISTINCT ' + COLUMN_NAME + ') ' +
        'WHEN COUNT(' + COLUMN_NAME + ') THEN ''UNIQUE WITH SINGLE NULL'' ' +
        'ELSE '''' ' +
        'END ' +
      'WHEN COUNT(' + COLUMN_NAME + ') THEN ''UNIQUE with NULLs'' ' +
      'ELSE '''' ' +
      'END AS ' + COLUMN_NAME
  FROM INFORMATION_SCHEMA.COLUMNS
  WHERE TABLE_NAME = @table
) s

SET @sql = 'SELECT ' + @sql + ' FROM ' + @table;
PRINT @sql;  /* in case you still want to have a look at the resulting query */
EXEC(@sql);
```
Cette solution prend les valeurs Null en compte par la vérification de trois valeurs: COUNT(DISTINCT column)COUNT(column) et COUNT(*). Il affiche les résultats de la même manière pour la première solution, mais les diagnostics possibles pour les colonnes sont de plus en plus diversifiée:
- UNIQUE signifie pas de les valeurs en double et pas de valeurs Null (peut être un PK ou ont une contrainte unique/index);
- UNIQUE WITH SINGLE NULL – comme on peut le deviner, pas de doublons, mais il y a un NULL (ne peut pas être un PK, mais peut avoir une contrainte unique/index);
- UNIQUE with NULLs – pas de doublons, de deux ou de plusieurs valeurs Null (dans le cas où vous êtes sur SQL Server 2008, vous pourriez avoir une condition index unique pour les valeurs non NULL);
- chaîne vide – il y a des doublons, éventuellement, les valeurs Null.
2

Ici c'est que je pense que probablement la façon la plus propre. Suffit d'utiliser le sql dynamique et une seule instruction select pour créer une requête qui vous donne un total de nombre de lignes et un nombre de valeurs distinctes pour chaque champ.

Remplir dans la base de données nom et le nom de la table dans la partie supérieure. Le nom DB partie est très importante puisqu' OBJECT_NAME ne fonctionne que dans l'actuel contexte de base de données.
```
use DatabaseName

DECLARE @Table varchar(100) = 'TableName'

DECLARE @SQL Varchar(max)

SET @SQL = 'SELECT COUNT(*) as ''Total'''

SELECT @SQL = @SQL + ',COUNT(DISTINCT ' + name + ') as ''' + name + ''''
FROM sys.columns c
WHERE OBJECT_NAME(object_id) = @Table

SET @SQL = @SQL + ' FROM ' + @Table

exec @sql
```
1

Si vous utilisez 2008, vous pouvez utiliser la Tâche de Profilage des Données dans SSIS de retour Candidat Clés pour chaque table.

Cette entrée de blog travers les différentes étapes du processus, c'est assez simple:

http://consultingblogs.emc.com/jamiethomson/archive/2008/03/04/ssis-data-profiling-task-part-8-candidate-key.aspx

Quelques mots ce que mon code n':

Lecture de toutes les tables et colonnes
Crée une table temporaire pour tenir des tables/colonnes avec des doubles de clés
Pour chaque table/colonne, il exécute une requête. Si elle trouve un count(*)>1 pour au moins une valeur
il permet une insertion dans la table temporaire

Sélectionnez la colonne et les valeurs dans les tables système qui ne correspondent pas à table/colonnes qui se trouvent à avoir des doublons

DECLARE @sql VARCHAR(max)
DECLARE @table VARCHAR(100)
DECLARE @column VARCHAR(100)


CREATE TABLE #temp (tname VARCHAR(100),cname VARCHAR(100))

DECLARE mycursor CURSOR FOR
select t.name,c.name
from sys.tables t
join sys.columns c on t.object_id = c.object_id
where system_type_id not in (34,35,99)

OPEN mycursor
FETCH NEXT FROM mycursor INTO @table,@column

WHILE @@FETCH_STATUS = 0
BEGIN
SET @sql = 'INSERT INTO #temp SELECT DISTINCT '''+@table+''','''+@column+ ''' FROM ' + @table + ' GROUP BY ' + @column +' HAVING COUNT(*)>1 '
EXEC (@sql)
FETCH NEXT FROM mycursor INTO @table,@column
END

select t.name,c.name
from sys.tables t
join sys.columns c on t.object_id = c.object_id
left join #temp on t.name = #temp.tname and c.name = #temp.cname
where system_type_id not in (34,35,99) and #temp.tname IS NULL

DROP TABLE #temp

CLOSE mycursor
DEALLOCATE mycursor

0

Qu'en simple ligne de code:
```
CREATE UNIQUE INDEX index_name ON table_name (column_name);
```
Si l'index est créé alors votre column_name a que des valeurs uniques. Si il y a des dupes dans votre column_name, vous obtiendrez un message d'erreur.

Vous devez vous connecter pour publier un commentaire.