So implementieren Sie eine MySQL-Datenbanksicherung in Golang

Typ OpFlag-Struktur {
  Tables bool //Tabellenstruktur Datum bool //Tabellenstruktur und Daten Views bool //Ansicht Funcs bool //Funktionen und gespeicherte Prozeduren}

 wenn len(os.Args) > 1 {
    Flagge = allgemein.OpFlag{
      Tabellen: false,
      Datum: false,
      Ansichten: falsch,
      Funktionen: false,
    }
    switch os.Args[1] { //Akzeptiere einen Parameter case "table":
      flag.Tables = true //Setze den Bezeichner entsprechend dem Parameter case "data":
      flag.Tabellen = true
      flag.Datum = true
    Fall „Ansichten“:
      flag.Ansichten = true
    Fall "Funktionen":
      flag.Funcs = true
    Standard: //Falsche Parameter, Fehler melden und Protokoll beenden.Schwerwiegend("Ihr Argument muss in Tabelle, Daten, Ansichten oder Funktionen enthalten sein.")
    }
  }else{ //Keine Parameter, alle Flags werden standardmäßig exportiert = common.OpFlag{
      Tabellen: true,
      Datum: wahr,
      Ansichten: wahr,
      Funktionen: true,
    }
  }
  err := backUp.Export(flag) Sichern Sie die Datenbank entsprechend den Parametern

var Konfigurationsschnittstelle{}
  fr, err := os.Open("./configs.json")
  wenn err != nil {
    Rückgabefehler
  }
  decoder := json.NewDecoder(fr) //Konfigurationsdatei analysieren err = decoder.Decode(&configs)
  confs := Konfigurationen.(map[string]Schnittstelle{})
  workDir := confs["workDir"].(Zeichenfolge)
  ch := make(chan string) //Kanalvariable für Schlüssel, Wert := Bereich confs {
    wenn strings.HasPrefix(Schlüssel, "db_") {
      dbConf := Wert.(map[string]interface{})
      dbConn := common.DbConnFields{ //Datenbankkonfiguration DbHost: dbConf["db_host"].(string),
        DbPort: int(dbConf["db_port"].(float64)),
        DbUser: dbConf["db_user"].(Zeichenfolge),
        DbPass: dbConf["db_pass"].(Zeichenfolge),
        DbName: dbConf["db_name"].(Zeichenfolge),
        DbCharset: dbConf["db_charset"].(Zeichenfolge),
      }
      if dbConf["file_alias"] != nil { //Generiere den Namen der SQL-Sicherungsdatei dbConn.FileAlias ​​​​= dbConf["file_alias"].(string)
      }
      go ExportOne(dbConn, workDir, ch, flag) //Coroutine erstellen}
  }
  for key := range confs { //Blockiere den Hauptprozess und warte bis alle Coroutinen ihre Arbeit beendet haben if strings.HasPrefix(key, "db_") {
      fmt.Print( <- ch )
    }
  }
  Rückgabe Null

{
  "Datenbankname1": {
    "db_host": "192.168.1.8",
    "db_port": 3306,
    "db_user": "root",
    "db_pass": "123456",
    "db_name": "name1",
    "db_charset": "utf8mb4",
    "file_alias": "Dateiname1"
  },
  "Datenbankname2": {
    "db_host": "lokaler Host",
    "db_port": 3306,
    "db_user": "root",
    "db_pass": "123456",
    "Datenbankname": "Name2",
    "db_charset": "utf8mb4"
  },
  "Datenbankdialekt": "mysql",
  "Arbeitsverzeichnis": "/home/zhoutk/gocodes/goTools/"
}

Dateiname := Felder.Dateialias
  setSqlHeader(fields, fileName) //Beschreibung der Exportdatei festlegen if flag.Tables { //Wenn die Tabelle auf true gesetzt ist, Tabellenstruktur exportieren err := exportTables(fileName, fields, flag) //Spezifische Algorithmen finden Sie im Quellcode if err != nil {
      ch <- fmt.Sprintln("Fehler: ", fields.DbName, "\t export tables throw, \t", err)
      zurückkehren
    }
  }
  if flag.Views { //Wenn die Ansicht auf „true“ gesetzt ist, exportiere die Ansicht err := exportViews(fileName, fields) //Den spezifischen Algorithmus findest du im Quellcode oder im Python-Algorithmus if err != nil {
      ch <- fmt.Sprintln("Fehler: ", fields.DbName, "\t export views throw, \t", err)
      zurückkehren
    }
  }
  if flag.Funcs { //Wenn die Funktion auf true gesetzt ist, werden Funktionen und gespeicherte Prozeduren exportiert err := exportFuncs(fileName, fields) //Spezifische Algorithmen finden Sie im Quellcode if err != nil {
      ch <- fmt.Sprintln("Fehler: ", fields.DbName, "\t export funcs throw, \t", err)
      zurückkehren
    }
  }
  //Export abgeschlossen, Eingabeinformationen zum Kanal ch <- fmt.Sprintln("Export ", fields.DbName, "\t Erfolg bei \t", time.Now().Format("2006-01-02 15:04:05"))

func ExecuteWithDbConn(sql string, Werte []Schnittstelle{}, Felder common.DbConnFields) (map[string]Schnittstelle{}, Fehler) {
  rs := make(map[string]schnittstelle{})
  dao, err := mysql.Open("mysql", Felder.DbUser + ":"+Felder.DbPass+"@tcp("+Felder.DbHost+":"+
    strconv.Itoa(Felder.DbPort)+")/"+Felder.DbName+"?charset="+Felder.DbCharset)
  verschieben dao.Close()
  wenn err != nil {
    rs["Code"] = 204
    returniere rs, err
  }
  stmt, err := dao.Vorbereiten(sql)
  wenn err != nil {
    rs["Code"] = 204
    returniere rs, err
  }
  Zeilen, Fehler := stmt.Query(Werte…)
  wenn err != nil {
    rs["Code"] = 204
    returniere rs, err
  }
  columns, err := rows.Columns() //Feldnamen abrufen vs := make([]mysql.RawBytes, len(columns))
  scannt := make([]interface{}, len(columns))
  für i := Bereich vs { //voreingestellter Wert Adresse scans[i] = &vs[i]
  }
  var Ergebnis []map[string]interface{}
  für Zeilen.Weiter() {
    _ = rows.Scan(scans...) //Geben Sie jeweils eine Spalte mit Werten ein := make(map[string]interface{})
    für i, col := Bereich vs {
      wenn col != nil {
        each[columns[i]] = FilterHolder(string(col)) //Filter/xfffd
      }anders{
        jede[Spalten[i]] = nil
      }
    }
    Ergebnis = Anhängen(Ergebnis, jedes)
  }
  rs["Code"] = 200
  //Daten, _ := json.Marshal(Ergebnis)
  rs["Zeilen"] = Ergebnis
  returniere rs, err
}

Git-Klon https://github.com/zhoutk/goTools
cd goTools
hol
Führen Sie main.go aus.
Erstellen Sie main.go
./main #alles aus der Datenbank exportieren
./Haupttabelle #Tabellen exportieren
./Hauptdaten #Tabellen und Daten exportieren
./Hauptansichten #Ansichten exportieren
./main funcs #Funktionen und gespeicherte Prozeduren exportieren