webentwicklung-frage-antwort-db.com.de

Wie exportiere ich eine MySQL-Datenbank nach JSON?

Ich bin daran interessiert, eine Teilmenge von Werten aus einer MySQL-Datenbank in eine JSON-formatierte Datei auf der Festplatte zu exportieren.

Ich habe einen Link gefunden, der einen möglichen Weg beschreibt: http://www.thomasfrank.se/mysql_to_json.html

... aber wenn ich die Methode von dieser Seite verwende, scheint es zu funktionieren, jedoch mit zwei Problemen:

1) Es gibt nur etwa 15 Ergebnisse zurück, wobei das letzte abrupt (unvollständig) abgeschnitten wird. Meine Standardabfrage für dieses Ergebnis gibt etwa 4000 Ergebnisse zurück, wenn ich es einfach als SELECT name, email FROM students WHERE enrolled IS NULL.__ starte, aber wenn ich es als:

SELECT 
     CONCAT("[",
          GROUP_CONCAT(
               CONCAT("{name:'",name,"'"),
               CONCAT(",email:'",email,"'}")
          )
     ,"]") 
AS json FROM students WHERE enrolled IS NULL;

... wie im Link beschrieben, gibt es (wie ich bereits erwähnt) nur 15 Ergebnisse zurück. (fwiw, ich habe diese Ergebnisse mit den 4000 verglichen, die ich bekommen soll, und diese 15 sind die gleichen wie die ersten 15 der 4000)

2) In der eigentlichen Datei sind scheinbar "Escape-Zeichen" enthalten, wenn ich am Ende dieser Abfrage INTO OUTFILE '/path/to/jsonoutput.txt' FIELDS TERMINATED BY ',' hinzufüge. Kommas sehen also wie "\" aus, wenn ich natürlich gerne die Kommas ohne das\hätte.

Irgendwelche Ideen, wie man eine korrekte JSON-Ausgabe von MySQL erhält? (Entweder mit dieser Methode oder einer anderen Methode)?

Vielen Dank!

45
mindthief

Es kann zu viel von MySQL verlangen, um zu erwarten, dass es direkt aus einer Abfrage wohlgeformten Json erzeugt. Erwägen Sie stattdessen, etwas bequemeres zu erstellen, wie beispielsweise CSV (mit dem INTO OUTFILE '/path/to/output.csv' FIELDS TERMINATED BY ','-Snippet, das Sie bereits kennen) und dann die Ergebnisse in Json in eine Sprache mit integrierter Unterstützung wie Python oder PHP umzuwandeln.

Edit python-Beispiel mit der feinen SQLAlchemy: 

class Student(object):
    '''The model, a plain, ol python class'''
    def __init__(self, name, email, enrolled):
        self.name = name
        self.email = email
        self.enrolled = enrolled

    def __repr__(self):
        return "<Student(%r, %r)>" % (self.name, self.email)

    def make_dict(self):
        return {'name': self.name, 'email': self.email}



import sqlalchemy
metadata = sqlalchemy.MetaData()
students_table = sqlalchemy.Table('students', metadata,
        sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True),
        sqlalchemy.Column('name', sqlalchemy.String(100)),
        sqlalchemy.Column('email', sqlalchemy.String(100)),
        sqlalchemy.Column('enrolled', sqlalchemy.Date)
    )

# connect the database.  substitute the needed values.
engine = sqlalchemy.create_engine('mysql://user:[email protected]/database')

# if needed, create the table:
metadata.create_all(engine)

# map the model to the table
import sqlalchemy.orm
sqlalchemy.orm.mapper(Student, students_table)

# now you can issue queries against the database using the mapping:
non_students = engine.query(Student).filter_by(enrolled=None)

# and lets make some json out of it:
import json
non_students_dicts = ( student.make_dict() for student in non_students)
students_json = json.dumps(non_students_dicts)

Wenn Sie über Ruby verfügen, können Sie das mysql2xxxx gem installieren (nicht das mysql2json gem, das ein anderes Juwel ist):

$ gem install mysql2xxxx

und dann den Befehl ausführen

$ mysql2json --user=root --password=password --database=database_name --execute "select * from mytable" >mytable.json

Der Edelstein enthält auch mysql2csv und mysql2xml. Es ist nicht so schnell wie mysqldump, leidet aber auch nicht an einigen Eigenheiten von mysqldump (zB wenn Sie nur CSV von demselben Computer wie den MySQL-Server selbst laden können).

34
Seamus Abshere

Dies sollte in der Anwendungsschicht erfolgen.

Zum Beispiel ist es in php so einfach wie

__Code-Auszug

$sql = "select ...";
$db = new PDO ( "mysql:$dbname", $user, $password) ;
$stmt = $db->prepare($sql);
$stmt->execute();
$result = $stmt->fetchAll();

file_put_contents("output.txt", json_encode($result));
10
Byron Whitlock

Eine andere Möglichkeit ist die Verwendung der MySQL Workbench.

Es gibt eine JSON-Exportoption im Kontextmenü des Objektbrowsers und im Ergebnisgittermenü.

Weitere Informationen zur MySQL-Dokumentation: Datenexport und -import .

9
Wtower

HeidiSQL erlaubt dies auch.

Markieren Sie beliebige Daten auf der Registerkarte DATEN oder im Abfrageergebnissatz. Klicken Sie dann mit der rechten Maustaste und wählen Sie die Option Rasterzeilen exportieren. Diese Option ermöglicht es Ihnen, alle Ihre Daten als JSON, direkt in die Zwischenablage oder direkt in eine Datei zu exportieren:

 enter image description here

8
jjj

Wenn Sie Ruby verwenden, können Sie mit ActiveRecord ein Verbindungsskript in die Datenbank schreiben. Sie müssen es zuerst installieren

gem install aktiverecord

# Ruby ./export-mysql.rb
require 'rubygems'
require 'active_record'

ActiveRecord::Base.establish_connection(
  :adapter => "mysql",
  :database => "database_name",
  :username => "root",
  :password => "",
  :Host => "localhost"
)

class Event < ActiveRecord::Base; end
class Person < ActiveRecord::Base; end

File.open("events.json", "w") { |f| f.write Event.all.to_json }
File.open("people.json", "w") { |f| f.write Person.all.to_json }

Sie können den ActiveRecord-Klassen auch Methoden hinzufügen, wenn Sie zuerst Daten bearbeiten oder bestimmte Spalten einschließen oder ausschließen möchten.

Person.all.to_json(:only => [ :id, :name ])

Mit ActiveRecord sind Sie nicht auf JSON beschränkt. Sie können genauso einfach wie XML oder YAML exportieren

Person.all.to_xml
Person.all.to_yaml

Sie sind nicht auf MySQL beschränkt. Jede von ActiveRecord unterstützte Datenbank (Postgres, SQLite3, Oracle ... usw.). 

Es ist erwähnenswert, dass Sie einen anderen Handle für eine Datenbank öffnen können

require 'active_record'

ActiveRecord::Base.configurations["mysql"] = {
  :adapter  => 'mysql',
  :database => 'database_name',
  :username => 'root',
  :password => '',
  :Host     => 'localhost'
}


ActiveRecord::Base.configurations["sqlite3"] = {
  :adapter  => 'sqlite3',
  :database => 'db/development.sqlite3'
}

class PersonMySQL < ActiveRecord::Base
  establish_connection "mysql"
end

class PersonSQLite < ActiveRecord::Base
  establish_connection "sqlite3"
end


PersonMySQL.all.each do |person|
    PersonSQLite.create(person.attributes.except("id"))
end

Hier ist ein kurzer kleiner Blogbeitrag dazu http://www.seanbehan.com/how-to-export-a-mysql-database-to-json-csv-and-xml-mit-Ruby-und-the -activerecord-gem

6
seanbehan

Ich weiß, das ist alt, aber für jemanden, der nach einer Antwort sucht ... 

Es gibt eine JSON-Bibliothek für MySQL, die Sie hier finden können Sie müssen Root-Zugriff auf Ihren Server haben und sich mit der Installation von Plugins vertraut machen (es ist ganz einfach).

1) Laden Sie die Datei lib_mysqludf_json.so in das Plugins-Verzeichnis Ihrer mysql-Installation

2) Führen Sie die Datei lib_mysqludf_json.sql aus (sie erledigt ziemlich viel Arbeit. Wenn Sie in Schwierigkeiten geraten, löschen Sie einfach alles, was mit 'DROP FUNCTION ...' beginnt)

3) Kodieren Sie Ihre Anfrage in etwa wie folgt:

SELECT json_array(
         group_concat(json_object( name, email))
FROM ....
WHERE ...

und es wird so etwas zurückgeben

[ 
   { 
     "name": "something",
     "email": "[email protected]"
    }, 
   { 
     "name": "someone",
     "email": "[email protected]"
    }

]
5
Patrick Pease

wie im Link beschrieben, gibt es (wie ich bereits erwähnt) nur 15 Ergebnisse zurück. (fwiw, ich habe diese Ergebnisse mit den 4000 verglichen, die ich bekommen soll, und diese 15 sind die gleichen wie die ersten 15 der 4000)

Das liegt daran, dass mysql die Länge der von group concat zurückgegebenen Daten auf den in @@ group_concat_max_len eingestellten Wert beschränkt, sobald der Betrag erreicht wird, den er abschneidet und zurückgibt, was er bisher erhalten hat.

Sie können @@ group_concat_max_len auf verschiedene Arten einstellen. Referenz Die MySQL-Dokumentation ...

2
robot_man

Sie können jede SQL-Abfrage direkt aus PHPMyAdmin in JSON exportieren

2
user2014202

Wenn Sie in der Anwendungsebene exportieren, vergessen Sie nicht, die Ergebnisse zu begrenzen. Wenn Sie beispielsweise 10 Millionen Zeilen haben, sollten Sie die Ergebnisse Teil für Teil erhalten.

1

Dies könnte eine Nischenlösung sein, aber wenn Sie Windows und MYSQL Workbench verwenden, können Sie einfach die gewünschte Tabelle auswählen und im Ergebnisbereich auf Exportieren/Importieren klicken. Dadurch erhalten Sie mehrere Formatoptionen, einschließlich .json

0
Jason

Mit der MySQL-Shell können Sie direkt mit nur einem Terminal in JSON ausgeben

echo "Your SQL query" | mysqlsh --sql --result-format=json --uri=[username]@localhost/[schema_name]
0
VIET THANG VU

Für alle, die dies mit Python tun möchten und alle Tabellen ohne vordefinierte Feldnamen usw. exportieren können, habe ich neulich ein kurzes Skript dafür geschrieben. Ich hoffe, jemand findet es nützlich:

from contextlib import closing
from datetime import datetime
import json
import MySQLdb
DB_NAME = 'x'
DB_USER = 'y'
DB_PASS = 'z'

def get_tables(cursor):
    cursor.execute('SHOW tables')
    return [r[0] for r in cursor.fetchall()] 

def get_rows_as_dicts(cursor, table):
    cursor.execute('select * from {}'.format(table))
    columns = [d[0] for d in cursor.description]
    return [dict(Zip(columns, row)) for row in cursor.fetchall()]

def dump_date(thing):
    if isinstance(thing, datetime):
        return thing.isoformat()
    return str(thing)


with closing(MySQLdb.connect(user=DB_USER, passwd=DB_PASS, db=DB_NAME)) as conn, closing(conn.cursor()) as cursor:
    dump = {}
    for table in get_tables(cursor):
        dump[table] = get_rows_as_dicts(cursor, table)
    print(json.dumps(dump, default=dump_date, indent=2))
0
hwjp

Verwenden Sie den folgenden Ruby-Code

require 'mysql2'

client = Mysql2::Client.new(
  :Host => 'your_Host', `enter code here`
  :database => 'your_database',
  :username => 'your_username', 
  :password => 'your_password')
table_sql = "show tables"
tables = client.query(table_sql, :as => :array)

open('_output.json', 'a') { |f|       
    tables.each do |table|
        sql = "select * from `#{table.first}`"
        res = client.query(sql, :as => :json)
        f.puts res.to_a.join(",") + "\n"
    end
}
0
Rahul Malhotra