So überprüfen Sie, ob eine MySQL-Datenbank vorhanden ist

Ist es möglich zu überprüfen, ob eine (MySQL) Datenbank vorhanden ist, nachdem eine Verbindung hergestellt wurde?

Ich kann überprüfen, ob eine Tabelle in einer Datenbank vorhanden ist, muss jedoch überprüfen, ob die Datenbank vorhanden ist. Wenn nicht, muss ich einen anderen Code aufrufen, um ihn zu erstellen und zu füllen.

Ich weiß, das klingt alles etwas unelegant - dies ist eine schnelle und schmutzige App.

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

Wenn Sie nur wissen müssen, ob eine Datenbank vorhanden ist, damit beim Versuch, sie zu erstellen, keine Fehlermeldung angezeigt wird, verwenden Sie einfach (Von hier ):

CREATE DATABASE IF NOT EXISTS DBName;

Eine einfache Möglichkeit, um zu überprüfen, ob eine Datenbank vorhanden ist, ist:

SHOW DATABASES LIKE 'dbname';

Wenn keine Datenbank mit dem Namen 'Datenbankname' vorhanden ist, erhalten Sie einen leeren Satz. Wenn es existiert, erhalten Sie eine Zeile.

Wenn Sie nach einem PHP-Skript suchen, siehe unten.

$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());
}

Aus der Schale wie 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

Hier ist eine Bash-Funktion zum Überprüfen, ob eine Datenbank vorhanden ist:

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
}           

Eine andere Alternative besteht darin, einfach zu versuchen, die Datenbank zu verwenden. Beachten Sie, dass dies auch die Berechtigung überprüft:

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

Eine gute Möglichkeit, um zu überprüfen, ob eine Datenbank in PHP vorhanden ist, ist:

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

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

Das ist die Methode, die ich immer benutze.

Ein sehr einfacher BASH-One-Liner:

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;

Für diejenigen, die PHP mit MySQL verwenden, ist dies meine Lösung. Ich weiß, dass die Antwort bereits beantwortet wurde, aber ich dachte, es wäre hilfreich, die Antwort auch als von mysqli vorbereitete Erklärung zu haben.

$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();

Bash verwenden:

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

Langwierig und verschlungen (aber ertrage es mit mir!), Hier ist ein Klassensystem, das ich erstellt habe, um zu überprüfen, ob eine Datenbank vorhanden ist, und um auch die erforderlichen Tabellen zu erstellen:

<?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;
    }
}

In diesem Fall können Sie den Datenbanknamen endurch einen beliebigen Datenbanknamen ersetzen und das Erstellungsskript in etwas ändern, das (hoffentlich!) Nicht beschädigt wird. Wenn jemand dies verbessern kann, lass es mich wissen!

Hinweis
Wenn Sie Visual Studio nicht mit PHP-Tools verwenden, sorgen Sie sich nicht um die Regionen, sondern um das Falten von Code: P.

Mit diesem Skript können Sie feststellen, dass eine Ja- oder Nein-Datenbank vorhanden ist. Falls diese nicht vorhanden ist, wird keine Ausnahme ausgelöst.

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

Schienencode:

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 existiert, entos_development1 existiert nicht

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

Wenn Sie MSSQL anstelle von MySQL verwenden, lesen Sie diese Antwort aus einem ähnlichen Thread .

Ich benutze einfach die folgende Abfrage:

"USE 'DBname'"

Überprüfen Sie dann, ob das Ergebnis FALSE ist. Andernfalls liegt möglicherweise ein Fehler bei der Zugriffsverweigerung vor, aber das kann ich nicht wissen. Im Falle von Privilegien kann man also verwenden:

"SHOW DATABASES LIKE 'DBname'"

wie bereits erwähnt.

Hier ist meine Vorgehensweise in einem Bash-Skript:

#!/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

Folgende Lösung hat bei mir funktioniert:

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

Eine andere PHP-Lösung, aber mit PDO:

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

Golang-Lösung

Erstellen Sie ein Testpaket und fügen Sie hinzu:

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")
    }

} 

Seien Sie vorsichtig, wenn Sie mit einer ähnlichen Aussage auf Existenz prüfen!

Wenn in einer Reihe unglücklicher Ereignisse Ihre Variable leer ist und Sie am Ende Folgendes ausführen:

SHOW DATABASES like '' -- dangerous!

Es gibt ALLE Datenbanken zurück und teilt dem aufrufenden Skript mit, dass es existiert, seit einige Zeilen zurückgegeben wurden.

Es ist viel sicherer und besser, ein Gleichheitszeichen "=" zu verwenden, um die Existenz zu testen.

Der richtige und sichere Weg, um seine Existenz zu testen, sollte sein:

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

Beachten Sie, dass Sie die Spaltennamendatenbank mit Backticks umschließen müssen. In diesem Fall kann keine entspannte Syntax verwendet werden.

Auf diese Weise gibt SHOW DATABASES nicht ALLE Datenbanken zurück, wenn der Code, der die Variable 'xxxxx' erstellt, leer ist, sondern eine leere Menge.