Grundlagen des MySQL-Datenbankbetriebs und Verwendung von MySQL in Node

Datenbank: Ein Lager, das Daten speichert.

Datenstruktur

Datenaustausch erreichen

Kann redundante Daten reduzieren

Hohe Datenunabhängigkeit

Einheitliche Datenverwaltung und -kontrolle

Datenbankeinführung

MySQL-Datenbank

Oracle

Das Datenbankverwaltungssystem Orcale wurde von Oracle entwickelt und ist führend im Datenbankbereich

Kommerziell Laden, Großsysteme, Taobao und JD.com verwenden die Oracle-Datenbank

SqlServer-Datenbank

wird von Microsoft entwickelt und kann nur unter Windows ausgeführt werden. Der .net-Entwicklungsprogrammierer

DB2

wurde von IBM entwickelt und ist in der Finanzbranche weit verbreitet. IBM-Server, kaufen Sie den Server und erhalten Sie die Datenbank kostenlos

Kommerzielle Gebühren

MS SQL Server

Die oben genannten Datenbanken werden mit der SQL-Sprache betrieben

SQL-Sprache ist eine Betriebssprache für relationale Datenbanken

Verwenden Sie diese SQL-Sprache zum Hinzufügen, Löschen und Ändern von Datenbanken und Tabellen sowie zum Hinzufügen, Löschen und Ändern von Tabellendaten

Tabellen sind Beziehungen

Tabellen und Es gibt Beziehungen zwischen Tabellen

MongoDB

Nicht relationale Datenbank

Es gibt keine Tabellen. Die in dieser Datenbank gespeicherten Daten sind alle in Sammlungen. Ähnlich wie bei JavaScript-Objekten, bei denen es sich tatsächlich um Daten im JSON-Format handelt.

Eine Sammlung hat keine Struktur. Eine Sammlung ist ein Array.

Sie können auch Daten in eine Sammlung einfügen.

MongoDB ist ein Hybrid zwischen einer relationalen Datenbank und einer von 10gen entwickelten Sammlung. Produkte unter den nicht-relationalen Datenbanken sind die funktionsreichsten unter den nicht-relationalen Datenbanken und sind den relationalen Datenbanken am ähnlichsten. Die unterstützte Datenstruktur ist sehr locker und hat ein JSON-ähnliches Format, sodass komplexere Datenstrukturtypen gespeichert werden können. Das größte Merkmal des MongoDB-Datenbankverwaltungssystems besteht darin, dass die unterstützte Abfragesprache sehr leistungsfähig ist und ihre Syntax der objektorientierten Abfragesprache ähnelt. Es handelt sich außerdem um eine Open-Source-Datenbank, die Internetanwendungen mit großen Datenmengen und hoher Parallelität unterstützt. Sie müssen die SQL-Sprache nicht verwenden, um nicht relationale Datenbanken zu betreiben.

Relationale Datenbankspeicherstruktur

Speicherdatensatzdaten entsprechend der Tabellenstruktur

Entwerfen Sie die Tabellenstruktur entsprechend dem Geschäft

Datenbankverwaltungssystem

Datenbankserver

Datenbank

Datentabelle

Datensatz

Oracle, SQLServer, DB2, MySQL sind alles relationale Datenbanken.

Installieren und konfigurieren Sie die MySQL-Datenbank

Offizielle Website: http://www.mysql.com/

Starten und stoppen Sie den MySQL-Dienst:

Geben Sie unter Windows „services.msc“ ein, um den MySQL-Dienst zu finden.

Starten Sie den MySQL-Dienst über DOS-Befehle (öffnen Sie das Terminal mit Administratorrechten).

Melden Sie sich an MySQL-Datenbank:

mysql -h localhost -P 3306 -u root -p

-h:hostname

-P:port

-u: Benutzername

-p: Passwort

mysql stellt standardmäßig eine Verbindung zu localhost und 3306 her, sodass Sie -h und -P weglassen können:

mysql -u root -p

Geben Sie in der Befehlszeile „help;“ oder „h“ ein, um MySQL-Hilfeinformationen anzuzeigen.

Datenbankspeicherstruktur

Ein Datenbankserver kann mehrere Datenbanken haben

Eine Datenbank kann mehrere Tabellen haben

A Tabelle muss eine Tabellenstruktur haben

Alle Daten werden in der Tabelle gespeichert. Nachdem Sie also eine Datenbank haben, müssen Sie zuerst Ihre Tabellenstruktur entwerfen

Speichern mehrerer Datensätze in einer Tabelle

Datensätze werden in Form einer Tabellenstruktur gespeichert

Datenbank und Tabelle erstellen

Datenbank erstellen

DATENBANK ERSTELLEN [IF NOT EXISTS] db_name

Datenbank anzeigen

DATENBANKEN ANZEIGEN;

Anweisung zur Datenbankerstellung anzeigen

SHOW CREATE DATABASE db_name;

Datenbank löschen

DROP DATABASE [IF EXISTS] db_name;

Datenbank auswählen

USE db_name;

Zeigt die aktuell verwendete Datenbank an

SELECT Datenbank();

Datentyp

Ganzzahltyp

Gleitkommatyp

In der MySQL-Datenbank werden Dezimalzahlen als Gleitkommazahlen und Festkommazahlen gespeichert.

Es gibt zwei Arten von Gleitkommazahlen:

Gleitkommazahl mit einfacher Genauigkeit (FLOAT)

Gleitkommazahl mit doppelter Genauigkeit (DOUBLE)

Fest Kommazahl (DEZIMAL) [ ˈdesɪml]

Zeit- und Datumstyp

Wenn der eingefügte Wert unzulässig ist, fügt das System automatisch den entsprechenden Nullwert in die Datenbank ein.

JAHR

wird durch eine vierstellige Zeichenfolge oder Zahl im Bereich von „1901“ bis „2155“ oder 1901 bis 2155 dargestellt.

Geben Sie beispielsweise „2016“ ein. oder 2016, Die in die Datenbank eingefügten Werte sind alle 2016

DATE

Der Typ DATE wird zur Darstellung von Datumswerten verwendet und enthält nicht den Zeitteil.

Sie können die Zeichenfolgendarstellung „JJJJ-MM-TT“ oder „JJJJMMTT“ verwenden.

Wenn Sie beispielsweise „2016-10-01“ oder „20161001“ eingeben, wird das Datum eingefügt Die Datenbank ist 2016 -10-01

TIME

Der Typ TIME wird zur Darstellung von Zeitwerten verwendet. Das Anzeigeformat ist im Allgemeinen HH:MM:SS, wobei HH für Stunden und MM für Minuten steht. und SS stellt Sekunden dar

Der Wert der Zeit kann auf die folgenden drei Arten angegeben werden:

Ausgedrückt im Zeichenfolgenformat „D HH:MM:SS“. Darunter stellt D den Tag dar, der einen Wert zwischen 0 und 34 annehmen kann. Beim Einfügen von Daten ist der Wert der Stunde gleich (D*24 HH)

Geben Sie beispielsweise „2 11“ ein: 30:50‘ zum Einfügen in die Datenbank Das Datum ist 59:30:50

Dargestellt im Zeichenfolgenformat „HHMMSS“ oder im Zahlenformat HHMMSS

Zum Beispiel: Geben Sie „345454“ oder 345454 ein. das in die Datenbank eingefügte Datum ist 34:54:54

Verwenden Sie CURRENT_TIME oder NOW(), um die aktuelle Systemzeit einzugeben

DATETIME

Geben Sie den Wert des Typs DATETIME an:

Verwenden Sie „JJJJ-MM-TT HH :MM:SS“ oder „JJJJMMTDHHMMSS“. Zeichenfolgen oder Zahlen sind akzeptabel.

Verwenden Sie NOW, um das aktuelle Systemdatum und die aktuelle Systemzeit einzugeben

TIMESTAMP

Das Anzeigeformat vom Typ TIMESTAMP ist dasselbe wie DATETIME, der Wertebereich ist jedoch kleiner als DATETIME.

Geben Sie CURRENT_TIMESTAMP ein, um das aktuelle Datum und die aktuelle Uhrzeit des Systems einzugeben.

Wenn Sie NULL eingeben, gibt das System automatisch das aktuelle Datum und die aktuelle Uhrzeit ein.

Wenn keine Eingabe erfolgt , das System gibt das aktuelle Datum und die aktuelle Uhrzeit der Systemzeitmarkierung

ein. Sie können damit den Zeitpunkt der letzten Änderung eines Datensatzes in der Tabelle speichern. Automatische Wartung.

CHAR und VARCHAR

Wenn die Daten vom Typ CHAR(4) sind, beträgt der belegte Speicherplatz unabhängig von der Länge des eingefügten Werts 4 Bytes. Die Anzahl der Bytes, die von den Daten entsprechend VARCHAR (4) belegt werden, ist die tatsächliche Länge plus 1.

Zusammenfassung:

Bei Typen mit variabler Zeichenlänge müssen die Bytes bei der Abfrage mit berechnet werden VARCHAR Die Länge von

ist fest und die CHAR-Abfrage ist schnell.

VARCAHR spart Platz als CHAR

CHAR spart Zeit als VARCHAR

TEXT-Typ

stellt große Textdaten wie Artikelinhalte, Kommentare usw. dar.

Grundfunktionen

Tabellenstruktur anzeigen

Alle Tabellen in der aktuellen Datenbank anzeigen: Tabellen anzeigen;

Tabellenstruktur anzeigen: desc Tabellenname;

Anweisungen zur Tabellenerstellung anzeigen: show create table table_name;

Datentabelle ändern

Spalten hinzufügen: ALTER TABLE table_name ADD colum datatype;

Spalten ändern: ALTER TABLE table_name MODIFY Spaltendatentyp;

Spalte löschen: ALTER TABLE Tabellenname DROP Spalte;

Tabellennamen ändern: TABLE Tabellenname in neuen_Tabellennamen umbenennen;

Spaltennamen ändern: ALTER TABLE Tabellenname Spaltennamen ändern new_colum_name datatype ;

DROP TABLE table_name Beschränken Sie die Felder in der Tabelle, um die Richtigkeit und Eindeutigkeit der Daten in der Datentabelle sicherzustellen.

Primärschlüsseleinschränkung

Jede Datentabelle kann höchstens eine Primärschlüsseleinschränkung haben. Felder, die als PRIMARY KEY definiert sind, dürfen keine doppelten Werte haben und können keine NULL-Werte sein. Das heißt, ungleich Null und eindeutig

Syntax: Feldname Datentyp PRIMARY KEY

Eindeutige Einschränkung

Eindeutige Einschränkung wird verwendet, um die Eindeutigkeit der Felder in der Datentabelle sicherzustellen, dh die Werte der Felder in der Tabelle können nicht wiederholt werden.

Syntax: Feldname-Datentyp UNIQUE;

Standardeinschränkungen

Standardeinschränkungen werden verwendet, um Standardwerte für Felder in der Datenbank anzugeben, d. h. beim Einfügen eines Wenn diesem Feld kein Wert zugewiesen ist, fügt das Datenbanksystem einen Standardwert für dieses Feld ein.

Syntax: Feldname Datentyp DEFAULT-Standardwert;

Stellen Sie den Feldwert der Tabelle so ein, dass er automatisch erhöht wird

Wenn Sie automatisch eine eindeutige ID für neue Datensätze generieren möchten in die Tabelle eingefügt. Sie können AUTO_INCREMENT verwenden, um

Syntax zu implementieren: Feldname Datentyp AUTO_INCREMENT;

Daten hinzufügen, aktualisieren und löschen

Daten hinzufügen

Für alle Felder hinzufügen in der Tabelle Daten

 INSERT INTO 表名  
 VALUES(列1值,列2值,...)

Hinweis: Die Werte in

Werte müssen den Feldern in der Tabelle entsprechen.

Die eingefügten Daten sollten vom gleichen Typ sein wie die Daten im Feld

Die Größe der Daten sollte innerhalb des angegebenen Bereichs der Spalte liegen, zum Beispiel eine Zeichenfolge mit der Länge 80 kann nicht in eine Zeichenfolge mit einer Länge von 40 eingefügt werden

Zeichen- und Datumsdaten in Spalten sollten in einfache Anführungszeichen gesetzt werden

Wenn Sie einen Nullwert einfügen möchten, geben Sie nicht NULL an oder verwenden Sie es nicht

um Daten gemäß der angegebenen Spalte hinzuzufügen:

 INSERT INTO 表名(列1名, 列2名,...)  
 VALUES(列1值, 列2值,...)

Hinweis: Die Werte in Werte müssen eins zu eins mit den Spalten in der Spaltendeklaration übereinstimmen

Mehrere Datensätze gleichzeitig hinzufügen

  INSERT INTO employee
  VALUES (value1,value2,value3...),
          (value1,value2,value3...),
          (value1,value2,value3),
          ...;

Alle Daten aktualisieren:

  UPDATE 表名
  SET 列名=值, 列名=值[,列名=值]

Aktualisiert durch Bedingungen:

  UPDATE 表名
  SET 列名=值, 列名=值[,列名=值]
  WHERE 条件;

Zusammenfassung:

Die UPDATE-Anweisung kann die Zeilenspalten in der Originaltabelle durch neue aktualisieren Werte.

SET-Klausel gibt an, welche Spalten geändert und welche Werte angegeben werden sollen

WHERE需要给定一个条件，表示要更新符号该条件的行，没有WHERE字句，则更新所有行

条件可以使用的运算符：

  -- 比较运算符 > < <= >= = <>  大于、小于、大于(小于等于)、不等于
  BETWEEN…AND -- 显示在某一区间的值
  IN(set) -- 显示在in列表中的值，例：in(100,200)
  LIKE -- ‘张pattern’ 模糊查询%
  IS NULL -- 判断是否为空

  -- 逻辑运算符 AND 多个条件同时成立
  OR  多个条件任一成立
  NOT 不成立，例：WHERE NOT(salary>100)

删除数据：

删除全部数据

DELETE FROM 表名;

根据条件删除：

 DELETE FROM 表名  WHERE 条件;

初始化

runcate初始化数据表

truncate table_name;

truncate和delete的区别：

delete会一条一条的删

truncate先摧毁整张表，再创建一张和原来的表结构一模一样的表

拿拆迁举例子

truncate在效率上比delete高

truncate只能删除整表的数据，也就是格式化。

truncate会把自增id截断恢复为1

总结：

如果不使用WHERE语句，将删除表中所有数据

DELETE不能删除某一列的值，（可使用UPDATE）

使用DELETE语句仅仅删除记录，不删除表本身，如果要删除表，使用DROP TABLE语句

删除表中所有数据也可以使用truncate table_name语句

单表查询

简单查询

SELECT [DISTINCT] *|{colum1, colum2, colum3...} FROM table_name;

SELECT指定查询哪些列的数据

column指定列名

号表示查询所有列

FROM 指定查询哪种表

DISTINCT 可选，指查询结果时，是否去除重复数据

查询表中所有数据：

SELECT * FROM 表名;

按照指定列查询表中所有数据：

SELECT 列名,列名[,列名] 
FROM 表名;

根据条件查询数据：

 SELECT * FROM 表名  
 WHERE 条件;

在WHERE字句中经常使用的运算符

LIKE语句中，% 代表零个或多个任意字符，_代表一个字符，例如：name LIKE '_a%';

多表查询：

  -- 多表查询
  -- 找到表 articles 中 user_id 等于 users 表中 id 的
  -- 多表查询可以起别名
  SELECT a.id as article_id, a.title, a.time
  FROM articles as a
  INSERT JOIN users as u
  ON a.user_id=u.id

查询总记录数：

  -- 查询表中的总记录数据
  SELECT COUNT(id) as count FROM articles;

聚合函数

在实际开发中，经常需要对某些数据进行统计，例如统计某个字段的最大值，最小值，平均值等，为此，MySQL提供了一些函数来实现这些功能。

COUNT（列名）返回某一列，行的总数

COUNT（列名）返回某一列，行的总数

SUM()函数返回满足WHERE条件的行的和

  SELECT SUM(列名) {, SUM(列名)...} FROM table_name
    [WHERE where_definition]

注意：SUM仅对数值起作用，否则报错; 对多列求和，“,”不能少。

MAX()/MIN()函数返回满足WHERE条件的一列的最大/最小值

  SELECT MAX(列名) FROM table_name
    [WHERE where_definition];

对查询结果排序

  SELECT colum1, colum2, colum3..
      FROM table_name
      ORDER BY colum ASC|DESC;

ORDER BY 指定排序的列，排序的列表即可以是表中的列名，也可以是SELECT语句后指定的列名.

ASC 升序，DESC 降序

ORDER BY 字句应该位于SELECT 语句的结尾

分组查询

  SELECT colum1, colum2, ...
    FROM 表名
    LIMIT [OFFSET, ] 记录数

LIMIT表示从哪一条记录开始往后【不包含该记录】，以及一共查询多少记录

OFFSET表示偏移量:

如果为0则表示从第一条记录开始

如果为5则表示从第6条记录开始

使用场景：分页查询

分页查询一个例子

  -- 仅仅取了前 10 条
  SELECET * FROM articles LIMIT 10
  -- 跳过一条取一条
  SELECET * FROM articles LIMIT 1, 1

为表和字段区别名

为表取别名

  SELECT 表别名.id,表别名.name... FROM 表名 AS 表别名
    WHERE 表别名.id = 2..

为字段取别名

  SELECT 字段名 [AS] 别名 [,字段名 [AS] 别名,...] FROM 表名;

多表操作

实际开发中业务逻辑比较复杂，可能有几十到几百张表不等，所以我们就需要对多张表来进行查询操作，对两张以上的表进行操作，就是多表操作。

外键

为了保证数据的完整性，将两张表之间的数据建立关系，因此就需要在成绩表中添加外键约束。

外键是指引用另一个表中的一列或多列，被引用的列应该具有主键约束或唯一约束。

外键用于建立和加强两个表数据之间的链接。

为表添加外键约束

创建表的时候添加外键:

  CREATE TABLE department(
      id INT PRIMARY KEY auto_increment,
      name VARCHAR(20) NOT NULL
  );
  CREATE TABLE employee(
      id INT PRIMARY KEY auto_increment,
      name VARCHAR(20) NOT NULL,
      dept_id INT,
      FOREIGN KEY (id) REFERENCES department(id)
  );

表已经存在，通过修改表的语句增加外键:

ALTER TABLE 表名 ADD CONSTRAINT 外键名 FOREIGN KEY(外键字段名) REFERENCES 外表表名(主键字段名);

删除外键约束

ALTER TABLE 表名 DROP FOREIGN KEY 外键名;

操作关联表

关联关系:

多对一

多对多

一对一

使用 Node 操作 MySQL 数据库

安装：

$ npm install --save mysql

使用连接池操作 MySQL 数据库

修改安装目录下 my.ini 文件中的: max_connections=1000 默认是 max_connections=151

重启服务器

连接池

封装过程：

  const mysql = require('mysql');

  // 使用连接，提高操作数据库效率
  // 创建一个连接池，池子存放的连接数量是 100 个
  const pool = mysql.createPool({
    connectionLimit: 100,
    host: 'localhost',
    user: 'root',
    password: 'root',
    database: 'personal'
  });

  for (let i = 0; i < 1000; i++) {
    // 从池子中拿一个可用的连接
    pool.getConnection((err, connection) => {
      if (err) {
        throw err;
      }
      connection.query(&#39;INSERT INTO `feedback`(`message`, `name`, `email`, `date`) VALUES(?, ?, ?, ?)&#39;, [
        &#39;今天的雾霾很醇厚&#39;,
        &#39;校长&#39;,
        &#39;xiaozhang@abc.com&#39;,
        &#39;2016-11-17 09:31:00&#39;
      ], (err, stat) => {
        // 尽早的释放回连接池
        // 只要操作数据库的回调函数被执行，说明这个连接的任务完成了
        connection.release();
        if (err) {
          throw err;
        }
        console.log(`第${i+1}个任务完成了`);
      });
    });
  }

封装：db.js

  const mysql = require('mysql');
  
  const pool = mysql.createPool({
    connectionLimit: 100,
    host: 'localhost',
    user: 'root',
    password: 'root',
    database: 'personal'
  });

  // rest 参数
  // 作为函数参数的最后一个参数出现，以 ... 开头，后面跟一个名字
  // rest 参数就代替了 arguments
  exports.query = function (sql, ...values) {
    let callback;
    let params = [];
    if (values.length === 3) {
      params = values[0];
      callback = values[1];
    } else if (values.length === 2) {
      callback = values[0];
    }
    pool.getConnection((err, connection) => {
      if (err) {
        return callback(err);
      }
      // 如果传递了两个参数，则第二个参数就是 callback
      // 也就是说这种情况下，params 就是 callback
      // 后面的 参数就忽略不计了
      // 如果真的传递了三个参数，那就是一一对应
      connection.query(sql, params, (err, result) => {
        connection.release();
        if (err) {
          return callback(err);
        }
        callback(null, result);
      });
    });
  };

promise 版

  const mysql = require('mysql');

  const pool = mysql.createPool({
    connectionLimit: 100,
    host: 'localhost',
    user: 'root',
    password: 'root',
    database: 'personal'
  });

  exports.query = (sql, params = []) => {
    return new Promise((resolve, reject) => {
      pool.getConnection((err, connection) => {
        if (err) {
          return reject(err);
        }
        connection.query(sql, params, (err, result) => {
          connection.release();
          if (err) {
            return reject(err);
          }
          resolve(result);
        });
      });
    });
  };

调用示例：

  const db = require('./db')

  db.query('SELECT 1 + 1 as solution');
    .then(rows => {
      // use rows
      return db.query('INSERT INTO table_name VALUES(?, ?, ?)', ['值1', '值2', '值3'])
    })
    .then(rows => {
      // use rows
    })
    .catch(err => {
      // handle error
    });