Requête MySQL pour obtenir les noms des colonnes?

Je voudrais obtenir tous les noms de col d'une table mysql dans un tableau en php?

Y a-t-il une requête à ce sujet?

La meilleure façon est d'utiliser la base de données virtuelle de métadonnées INFORMATION_SCHEMA . Plus précisément, la table INFORMATION_SCHEMA.COLUMNS ...

SELECT `COLUMN_NAME` 
FROM `INFORMATION_SCHEMA`.`COLUMNS` 
WHERE `TABLE_SCHEMA`='yourdatabasename' 
    AND `TABLE_NAME`='yourtablename';

Il est TRÈS puissant et peut vous donner des TONNES d'informations sans avoir besoin d'analyser le texte (comme le type de colonne, si la colonne est annulable, la taille maximale de la colonne, le jeu de caractères, etc.) ...

Oh, et c'est du SQL standard (alors que SHOW ...c'est une extension spécifique à MySQL) ...

Pour plus d'informations sur la différence entre SHOW...les INFORMATION_SCHEMAtables et leur utilisation , consultez la documentationINFORMATION_SCHEMA MySQL sur en général ...

Vous pouvez utiliser la requête suivante pour MYSQL:

SHOW columns FROM your-table;

Voici l'exemple de code qui montre comment implémenter la syntaxe ci-dessus en php pour répertorier les noms des colonnes:

$sql = "SHOW COLUMNS FROM your-table";
$result = mysqli_query($conn,$sql);
while($row = mysqli_fetch_array($result)){
    echo $row['Field']."<br>";
}

Pour plus de détails sur la sortie de SHOW COLUMNS FROM TABLEvisite: MySQL Refrence.

Semble qu'il existe 2 façons:

DESCRIBE `tablename`

ou

SHOW COLUMNS FROM `tablename`

Plus d'informations DESCRIBEici: http://dev.mysql.com/doc/refman/5.0/en/describe.html

Je l'ai fait dans le passé.

SELECT column_name
FROM information_schema.columns
WHERE table_name='insert table name here'; 

Edit : Aujourd'hui, j'ai appris la meilleure façon de le faire. Veuillez consulter la réponse d'ircmaxell.

Analyser la sortie de SHOW COLUMNS FROM table;

En savoir plus à ce sujet ici: http://dev.mysql.com/doc/refman/5.0/en/show-columns.html

Utilisez mysql_fetch_field()pour afficher toutes les données de colonne. Voir manuel .

$query = 'select * from myfield';
$result = mysql_query($query);
$i = 0;
while ($i < mysql_num_fields($result))
{
   $fld = mysql_fetch_field($result, $i);
   $myarray[]=$fld->name;
   $i = $i + 1;
}

"Avertissement Cette extension est déconseillée à partir de PHP 5.5.0 et sera supprimée à l'avenir."

Une ancienne fonction PHP "mysql_list_fields ()" est obsolète. Donc, aujourd'hui, la meilleure façon d'obtenir les noms des champs est une requête "SHOW COLUMNS FROM table_name [LIKE 'name']". Voici donc un petit exemple:

$fields = array();
$res=mysql_query("SHOW COLUMNS FROM mytable");
while ($x = mysql_fetch_assoc($res)){
  $fields[] = $x['Field'];
}
foreach ($fields as $f) { echo "<br>Field name: ".$f; }

function get_col_names(){  
    $sql = "SHOW COLUMNS FROM tableName";  
    $result = mysql_query($sql);     
    while($record = mysql_fetch_array($result)){  
     $fields[] = $record['0'];  
    }
    foreach ($fields as $value){  
      echo 'column name is : '.$value.'-';  
}  
 }  

return get_col_names();

Je ne sais pas si c'est ce que vous cherchiez, mais cela a fonctionné pour moi:

$query = query("DESC YourTable");  
$col_names = array_column($query, 'Field');

Cela renvoie un simple tableau des noms de colonnes / noms de variables dans votre table ou tableau sous forme de chaînes, ce dont j'avais besoin pour créer dynamiquement des requêtes MySQL. Ma frustration était que je ne savais tout simplement pas très bien comment indexer les tableaux en PHP, donc je ne savais pas quoi faire avec les résultats de DESC ou SHOW. J'espère que ma réponse sera utile aux débutants comme moi!

Pour vérifier le résultat: print_r($col_names);

lorsque vous souhaitez vérifier la structure de toutes vos tables avec certains fichiers, utilisez ce code. Dans cette requête, je sélectionne nom_colonne, type_colonne et nom_table pour plus de détails. J'utilise order by column_type pour que je puisse le voir facilement.

SELECT `COLUMN_NAME`,COLUMN_TYPE,TABLE_NAME 
FROM `INFORMATION_SCHEMA`.`COLUMNS` 
WHERE `TABLE_SCHEMA`='yourdatabasename' order by DATA_TYPE;

Si vous ne souhaitez vérifier que le type double déposé, vous pouvez le faire facilement

SELECT `COLUMN_NAME`,COLUMN_TYPE,TABLE_NAME,DATA_TYPE 
FROM `INFORMATION_SCHEMA`.`COLUMNS` 
WHERE `TABLE_SCHEMA`='yourdatabasename' AND DATA_TYPE like '%bigint%'  order by DATA_TYPE;

si vous voulez vérifier quel champ autorise le type null, etc., vous pouvez l'utiliser

SELECT `COLUMN_NAME`,COLUMN_TYPE,TABLE_NAME,IS_NULLABLE,DATA_TYPE 
FROM `INFORMATION_SCHEMA`.`COLUMNS` 
WHERE `TABLE_SCHEMA`='yourdatabasename' and DATA_TYPE like '%bigint%' and IS_NULLABLE ='NO' order by COLUMN_TYPE;

vous voulez vérifier plus puis le lien thik vous aide également.

https://dev.mysql.com/doc/refman/5.7/en/columns-table.html

SHOW COLUMNS dans mysql 5.1 (pas 5.5) utilise une table de disque temporaire.

• http://dev.mysql.com/doc/refman/5.1/en/internal-temporary-tables.html
• http://dev.mysql.com/doc/refman/5.1/en/show-columns.html

Cela peut donc être considéré comme lent dans certains cas. Au moins, il peut augmenter votre valeur created_tmp_disk_tables . Imaginez une table de disque temporaire par connexion ou par chaque demande de page.

SHOW COLUMNS n'est pas vraiment si lent, peut-être parce qu'il utilise le cache du système de fichiers. Phpmyadmin indique ~ 0,5 ms de manière cohérente. Ce n'est rien comparé à 500ms-1000ms de diffusion d'une page wordpress. Mais encore, il y a des moments où cela compte. Il y a une implication du système de disque, vous ne savez jamais ce qui se passe lorsque le serveur est occupé, le cache est plein, le disque dur est bloqué, etc.

La récupération des noms de colonne via SELECT * FROM ... LIMIT 1 était d'environ ~ 0,1 ms, et elle peut également utiliser le cache de requêtes.

Voici donc mon petit code optimisé pour obtenir les noms des colonnes d'une table, sans utiliser si possible les colonnes show :

function db_columns_ar($table)
{
//returns Array('col1name'=>'col1name','col2name'=>'col2name',...)
if(!$table) return Array();
if(!is_string($table)) return Array();

global $db_columns_ar_cache;
if(!empty($db_columns_ar_cache[$table]))
    return $db_columns_ar_cache[$table];


//IMPORTANT show columns creates a temp disk table
$cols=Array();
$row=db_row_ar($q1="SELECT * FROM `$table` LIMIT 1");
if($row)
    {
    foreach($row as $name=>$val)
        $cols[$name]=$name;
    }
else
    {
    $coldata=db_rows($q2="SHOW COLUMNS FROM `$table`");
    if($coldata)
        foreach($coldata as $row)
            $cols[$row->Field]=$row->Field;
    }
$db_columns_ar_cache[$table]=$cols;
//debugexit($q1,$q2,$row,$coldata,$cols);
return $cols;
}

Remarques:

• Tant que la première ligne de vos tableaux ne contient pas de plage de mégaoctets de données, cela devrait fonctionner correctement.
• Les noms de fonction db_rows et db_row_ar doivent être remplacés par votre configuration de base de données spécifique.

Essayez celui-ci, je l'utilise personnellement:

SHOW COLUMNS FROM $table where field REGEXP 'stock_id|drug_name' 

EN WORDPRESS:

global $wpdb;   $table_name=$wpdb->prefix.'posts';
foreach ( $wpdb->get_col( "DESC " . $table_name, 0 ) as $column_name ) {
  var_dump( $column_name );
}

Cette question est ancienne, mais je suis arrivé ici à la recherche d'un moyen de trouver une requête donnée ses noms de champs de manière dynamique (pas nécessairement uniquement les champs d'une table). Et comme les gens continuent de pointer cela comme la réponse à cette tâche donnée dans d'autres questions connexes, je partage la façon dont j'ai trouvé que cela pouvait être fait, en utilisant les conseils de Gavin Simpson:

//Function to generate a HTML table from a SQL query
function myTable($obConn,$sql)
{
    $rsResult = mysqli_query($obConn, $sql) or die(mysqli_error($obConn));
    if(mysqli_num_rows($rsResult)>0)
    {
        //We start with header. >>>Here we retrieve the field names<<<
        echo "<table width=\"100%\" border=\"0\" cellspacing=\"2\" cellpadding=\"0\"><tr align=\"center\" bgcolor=\"#CCCCCC\">";
        $i = 0;
        while ($i < mysqli_num_fields($rsResult)){
           $field = mysqli_fetch_field_direct($rsResult, $i);
           $fieldName=$field->name;
           echo "<td><strong>$fieldName</strong></td>";
           $i = $i + 1;
        }
        echo "</tr>"; 
        //>>>Field names retrieved<<<

        //We dump info
        $bolWhite=true;
        while ($row = mysqli_fetch_assoc($rsResult)) {
            echo $bolWhite ? "<tr bgcolor=\"#CCCCCC\">" : "<tr bgcolor=\"#FFF\">";
            $bolWhite=!$bolWhite;
            foreach($row as $data) {
                echo "<td>$data</td>";
            }
            echo "</tr>";
        }
        echo "</table>";
    }
}

Cela peut être facilement modifié pour insérer les noms de champ dans un tableau.

Utilisation d'un simple: $sql="SELECT * FROM myTable LIMIT 1"peut vous donner les champs de n'importe quelle table, sans avoir besoin d'utiliserSHOW COLUMNS ou de module php supplémentaire, si nécessaire (suppression de la partie de vidage de données).

J'espère que cela aide quelqu'un d'autre.

si vous utilisez php, utilisez cet essentiel .

il peut obtenir des informations complètes sur certains champs sans résultat ， et tous les champs personnalisés tels que:

SELECT a.name aname, b.name bname, b.* 
FROM table1 a LEFT JOIN table2 b
ON a.id = b.pid;

si au-dessus de sql ne renvoie aucune donnée, obtiendra également les noms de champ aname, bname, l'autre nom de champ de b

juste deux lignes:

$query_info = mysqli_query($link, $data_source);
$fetch_fields_result = $query_info->fetch_fields();

Cette requête récupère une liste de toutes les colonnes d'une base de données sans avoir à spécifier de nom de table. Il renvoie une liste de noms de colonnes uniquement:

SELECT COLUMN_NAME
  FROM INFORMATION_SCHEMA.COLUMNS
  WHERE table_schema = 'db_name'

Cependant, lorsque j'ai exécuté cette requête dans phpmyadmin, elle a affiché une série d'erreurs. Néanmoins, cela a fonctionné. Alors utilisez-le avec prudence.

La solution la plus simple de toutes les réponses:

DESC `table name`

ou

DESCRIBE `table name`

ou

SHOW COLUMNS FROM `table name`

si vous n'avez besoin que des noms et des types de champs (peut-être pour un copier-coller facile dans Excel):

SELECT COLUMN_NAME, DATA_TYPE
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA='databasenamegoeshere'
AND DATA_TYPE='decimal' and TABLE_NAME = 'tablenamegoeshere'

retirer

DATA_TYPE='decimal'

si vous voulez tous les types de données

je aucun expert, mais cela fonctionne pour moi ..

$sql = "desc MyTable";
$result = @mysql_query($sql);
while($row = @mysql_fetch_array($result)){
    echo $row[0]."<br>"; // returns the first column of array. in this case Field

      // the below code will return a full array-> Field,Type,Null,Key,Default,Extra    
      // for ($c=0;$c<sizeof($row);$c++){echo @$row[$c]."<br>";}    

}

J'ai essayé cette requête dans SQL Server et cela a fonctionné pour moi:

SELECT name FROM sys.columns WHERE OBJECT_ID = OBJECT_ID('table_name')