Comment vérifier si la base de données mysql existe

Est-il possible de vérifier si une base de données (MySQL) existe après avoir établi une connexion.

Je sais comment vérifier si une table existe dans une base de données, mais je dois vérifier si la base de données existe. Sinon, je dois appeler un autre morceau de code pour le créer et le remplir.

Je sais que tout cela semble quelque peu inélégant - c'est une application rapide et sale.

SELECT SCHEMA_NAME
  FROM INFORMATION_SCHEMA.SCHEMATA
 WHERE SCHEMA_NAME = 'DBName'

Si vous avez juste besoin de savoir si une base de données existe afin que vous n'obteniez pas d'erreur lorsque vous essayez de la créer, utilisez simplement (From here ):

CREATE DATABASE IF NOT EXISTS DBName;

Un moyen simple de vérifier si une base de données existe est:

SHOW DATABASES LIKE 'dbname';

Si la base de données portant le nom «dbname» n'existe pas, vous obtenez un ensemble vide. S'il existe, vous obtenez une ligne.

Si vous cherchez un script php voir ci-dessous.

$link = mysql_connect('localhost', 'mysql_user', 'mysql_password');
if (!$link) {
  die('Not connected : ' . mysql_error());
}

// make foo the current db
$db_selected = mysql_select_db('foo', $link);
if (!$db_selected) {
  die ('Cannot use foo : ' . mysql_error());
}

De la coquille comme bash

if [[ ! -z "`mysql -qfsBe "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME='db'" 2>&1`" ]];
then
  echo "DATABASE ALREADY EXISTS"
else
  echo "DATABASE DOES NOT EXIST"
fi

Voici une fonction bash pour vérifier si une base de données existe:

function does_db_exist {
  local db="${1}"

  local output=$(mysql -s -N -e "SELECT schema_name FROM information_schema.schemata WHERE schema_name = '${db}'" information_schema)
  if [[ -z "${output}" ]]; then
    return 1 # does not exist
  else
    return 0 # exists
  fi
}           

Une autre alternative consiste à simplement essayer d'utiliser la base de données. Notez que cela vérifie également l'autorisation:

if mysql "${db}" >/dev/null 2>&1 </dev/null
then
  echo "${db} exists (and I have permission to access it)"
else
  echo "${db} does not exist (or I do not have permission to access it)"
fi

Un excellent moyen de vérifier si une base de données existe en PHP est:

$mysql = mysql_connect("<your host>", "root", "");

if (mysql_select_db($mysql, '<your db name>')) {
    echo "Database exists";
} else {
    echo "Database does not exist";
}

C'est la méthode que j'utilise toujours.

Un BASH-one-liner très simple:

mysqlshow | grep dbname

CREATE SCHEMA IF NOT EXISTS `demodb` DEFAULT CHARACTER SET utf8 ;

SELECT IF('database_name' IN(SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA), 1, 0) AS found;

Pour ceux qui utilisent php avec mysqli, voici ma solution. Je sais que la réponse a déjà été répondue, mais j'ai pensé qu'il serait utile d'avoir la réponse en tant que déclaration préparée par mysqli aussi.

$db = new mysqli('localhost',username,password);
$database="somedatabase";
$query="SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME=?";
$stmt = $db->prepare($query);
$stmt->bind_param('s',$database);
$stmt->execute();
$stmt->bind_result($data);
if($stmt->fetch())
{
    echo "Database exists.";
}
else
{
    echo"Database does not exist!!!";
}
$stmt->close();

Utilisation de bash:

if [ "`mysql -u'USER' -p'PASSWORD' -se'USE $DATABASE_NAME;' 2>&1`" == "" ]; then
    echo $DATABASE_NAME exist
else
    echo $DATABASE_NAME doesn't exist
fi

Longue haleine et alambiquée (mais restez avec moi!), Voici un système de classe que j'ai fait pour vérifier si une DB existe et aussi pour créer les tables nécessaires:

<?php
class Table
{
    public static function Script()
    {
        return "
            CREATE TABLE IF NOT EXISTS `users` ( `id` INT NOT NULL PRIMARY KEY AUTO_INCREMENT );

        ";
    }
}

class Install
{
    #region Private constructor
    private static $link;
    private function __construct()
    {
        static::$link = new mysqli();
        static::$link->real_connect("localhost", "username", "password");
    }
    #endregion

    #region Instantiator
    private static $instance;
    public static function Instance()
    {
        static::$instance = (null === static::$instance ? new self() : static::$instance);
        return static::$instance;
    }
    #endregion

    #region Start Install
    private static $installed;
    public function Start()
    {
        var_dump(static::$installed);
        if (!static::$installed)
        {
            if (!static::$link->select_db("en"))
            {
                static::$link->query("CREATE DATABASE `en`;")? $die = false: $die = true;
                if ($die)
                    return false;
                static::$link->select_db("en");
            }
            else
            {
                static::$link->select_db("en");          
            }
            return static::$installed = static::DatabaseMade();  
        }
        else
        {
            return static::$installed;
        }
    }
    #endregion

    #region Table creator
    private static function CreateTables()
    {
        $tablescript = Table::Script();
        return static::$link->multi_query($tablescript) ? true : false;
    }
    #endregion

    private static function DatabaseMade()
    {
        $created = static::CreateTables();
        if ($created)
        {
            static::$installed = true;
        }
        else
        {
            static::$installed = false;
        }
        return $created;
    }
}

En cela, vous pouvez remplacer le nom de la base de données enpar n'importe quel nom de base de données que vous aimez et également changer le script du créateur en n'importe quoi et (espérons-le!) Il ne le cassera pas. Si quelqu'un peut améliorer cela, faites le moi savoir!

Remarque
Si vous n'utilisez pas Visual Studio avec des outils PHP, ne vous inquiétez pas pour les régions, ce sont elles pour le pliage de code: P

Avec ce script, vous pouvez obtenir une base de données Oui ou Non, au cas où elle n’existerait pas, elle ne lèverait pas d’exception.

SELECT 
    IF(EXISTS( SELECT 
                SCHEMA_NAME
            FROM
                INFORMATION_SCHEMA.SCHEMATA
            WHERE
                SCHEMA_NAME = 'DbName'),
        'Yes',
        'No')  as exist

Code Rails:

ruby-1.9.2-p290 :099 > ActiveRecord::Base.connection.execute("USE INFORMATION_SCHEMA")

ruby-1.9.2-p290 :099 > ActiveRecord::Base.connection.execute("SELECT SCHEMA_NAME FROM         INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = 'entos_development'").to_a
SQL (0.2ms) SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME =               'entos_development'
=> [["entos_development"]] 
ruby-1.9.2-p290 :100 > ActiveRecord::Base.connection.execute("SELECT SCHEMA_NAME FROM              INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = 'entos_development1'").to_a
SQL (0.3ms) SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME =            'entos_development1'
=> []

=> entos_development existe, entos_development1 n'existe pas

IF EXISTS (SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = N'YourDatabaseName')
BEGIN    
    -- Database exists, so do your stuff here.
END

Si vous utilisez MSSQL au lieu de MySQL, consultez cette réponse à partir d'un fil similaire .

J'utilise simplement la requête suivante:

"USE 'DBname'"

Vérifiez ensuite si le résultat est FAUX. Sinon, il pourrait y avoir une erreur d'accès refusé, mais je ne peux pas le savoir. Ainsi, en cas de privilèges impliqués, on peut utiliser:

"SHOW DATABASES LIKE 'DBname'"

comme déjà mentionné précédemment.

Voici ma façon de le faire dans un script bash:

#!/bin/sh

DATABASE_USER=*****
DATABASE_PWD=*****
DATABASE_NAME=my_database

if mysql -u$DATABASE_USER -p$DATABASE_PWD -e "use $DATABASE_NAME";
then
echo "Database $DATABASE_NAME already exists. Exiting."
exit
else
echo Create database
mysql -u$DATABASE_USER -p$DATABASE_PWD -e "CREATE DATABASE $DATABASE_NAME"
fi

La solution suivante a fonctionné pour moi:

mysql -u${MYSQL_USER} -p${MYSQL_PASSWORD} \
-s -N -e "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME='${MYSQL_DATABASE}'"

Une autre solution php, mais avec PDO:

<?php
try {
   $pdo = new PDO('mysql:host=localhost;dbname=dbname', 'root', 'password');
   echo 'table dbname exists...';
}
catch (PDOException $e) {
   die('dbname not found...');
}

Solution de Golang

créer un package de test et ajouter:

import "database/sql"

// testing database creation
func TestCreate(t *testing.T){
    Createdb("*Testdb") // This just calls the **sql.DB obect *Testdb 
    db,err := sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/*Testdb")
    if err != nil{
        panic(err)
    }
    defer db.Close()
    _, err = db.Exec("USE *Testdb")
    if err != nil{
        t.Error("Database not Created")
    }

} 

Soyez prudent lorsque vous vérifiez l'existence avec une déclaration similaire!

Si dans une série d'événements malheureux votre variable finit par être vide, et vous finissez par exécuter ceci:

SHOW DATABASES like '' -- dangerous!

Il renverra TOUTES les bases de données, indiquant ainsi au script appelant qu'il existe puisque certaines lignes ont été renvoyées.

Il est beaucoup plus sûr et préférable d'utiliser un signe égal "=" pour tester l'existence.

La manière correcte et sûre de tester l'existence devrait être:

SHOW DATABASES WHERE `database` = 'xxxxx' -- safe way to test for existence

Notez que vous devez encapsuler la base de données de noms de colonnes avec des astuces, elle ne peut pas utiliser une syntaxe détendue dans ce cas.

De cette façon, si le code créant la variable 'xxxxx' est retourné vide, alors SHOW DATABASES ne renverra pas TOUTES les bases de données, mais renverra un ensemble vide.