Merge pull request #48 from givery-technology/mysql-support

[CIT-949] MySQL support

Author: a-miyashita

README.md

@@ -15,6 +15,10 @@ This software is released under the [MIT License](LICENSE).
 
 ## Release Note
 
+### Version 2.6.0
+
+* [Feat] MySQL support
+
 ### Version 2.5.0
 
 * [Feat] Allow multiple checks in a single testcase (Runner)

lib/connection.js

@@ -5,6 +5,7 @@ const knex = require('knex');
 const path = require('path');
 const util = require('util');
 const _ = require('./i18n').text;
+const exec = util.promisify(cp.exec);
 
 const NULL_MARKER = '__null__';
 const SQL_ERROR = {
@@ -57,6 +58,12 @@ function typeOf(x) {
 	return Object.prototype.toString.call(x).slice(8, -1).toLowerCase();
 }
 
+async function sleep(ms) {
+	return new Promise((res, rej) => {
+		setTimeout(() => res(), ms);
+	});
+}
+
 class SQLiteCasette {
 	async newConnection(options) {
 		const dbfile = (options || {}).file || 'db.sqlite';
@@ -71,6 +78,9 @@ class SQLiteCasette {
 			useNullAsDefault: true
 		});
 	}
+	rows(result) {
+		return result;
+	}
 	explainSql(s) {
 		return `EXPLAIN QUERY PLAN ${s}`;
 	}
@@ -131,13 +141,6 @@ class SQLiteCasette {
 
 class PostgreSQLCasette {
 	async newConnection(options) {
-		const exec = util.promisify(cp.exec);
-		async function sleep(ms) {
-			return new Promise((res, rej) => {
-				setTimeout(() => res(), ms);
-			});
-		}
-
 		async function startServer() {
 			return new Promise((_res, _rej) => {
 				let done = false;
@@ -223,6 +226,9 @@ class PostgreSQLCasette {
 		}
 		throw Error("Failed to start PostgreSQL server");
 	}
+	rows(result) {
+		return result.rows;
+	}
 	explainSql(s) {
 		return `EXPLAIN ${s}`;
 	}
@@ -262,8 +268,81 @@ class PostgreSQLCasette {
 	}
 }
 
+class MySQLCassette {
+	async newConnection(options) {
+		for (let retries = 10; retries > 0; retries--) {
+			try {
+				exec('service mysql start');
+				const conn = knex({
+					client: 'mysql',
+					connection: {
+						host: '127.0.0.1',
+						port: 3306,
+						user: 'track',
+						password: 'password',
+						database: 'track',
+					},
+				});
+				await conn.raw("SELECT 1");
+				if (options && options.clean) {
+					try {
+						let tables = await conn.raw("SHOW TABLES");
+						for (let table of tables[0]) {
+							await conn.raw(`DROP TABLE IF EXISTS ${table.Tables_in_track} CASCADE`);
+						}
+					} catch (e2) { console.error(e2); }
+				}
+				return conn;
+			} catch (e) {
+				await sleep(500);
+			}
+		}
+		throw Error("Failed to start MySQL server");
+	}
+	rows(result) {
+		return result[0];
+	}
+	explainSql(s) {
+		return `EXPLAIN ${s}`;
+	}
+	tableSchemaSql() {
+		return `
+			SELECT
+				ordinal_position AS "order",
+				column_name AS name,
+				data_type AS raw_type
+			FROM information_schema.columns
+			WHERE
+				table_schema = 'track' AND
+				table_name = ?
+			ORDER BY ordinal_position
+		`;
+	}
+	updateAutoIncrementSql(table, column) {
+		return `ALTER TABLE ${table} AUTO_INCREMENT = ? + 1`;
+	}
+	lastValueSql(table, idCol) {
+		return `SELECT * FROM ${table} WHERE ${idCol} = LAST_INSERT_ID()`;
+	}
+	async listFk(table, conn) {
+		return await conn.query(`
+			SELECT
+				kcu.column_name AS column,
+				ccu.table_name AS foreign_table,
+				ccu.column_name AS foreign_column
+			FROM information_schema.table_constraints AS tc
+			INNER JOIN information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+			INNER JOIN information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+			WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = '${table}'
+		`);
+	}
+	errorOf(e) {
+		return [SQL_ERROR.UNKNOWN];
+	}
+}
+
 /**
- * Handles SQLite connection
+ * Handles connection
  */
 class Connection {
 	static timeout(client, extra) {
@@ -272,6 +351,9 @@ class Connection {
 			case "postgres":
 			case "postgresql":
 				return 12000 + (extra || 0);
+			case "my":
+			case "mysql":
+				return 12000 + (extra || 0);
 			default:
 				return 2000 + (extra || 0);
 		}
@@ -284,6 +366,10 @@ class Connection {
 			case "postgresql":
 				casette = new PostgreSQLCasette(options);
 				break;
+			case "my":
+			case "mysql":
+				casette = new MySQLCassette(options);
+				break;
 			default:
 				casette = new SQLiteCasette(options);
 				break;
@@ -417,24 +503,19 @@ class Connection {
 	 * @returns {Promise<Array<object>?>}
 	 */
 	async query(sql, opt_args) {
-
-		function rows(records) {
-			return !!records.rows ? records.rows /* postgres */ : records /* sqlite */
-		}
-
 		if (sql.trim().length === 0) {
 			throw 'Empty query';
 		}
 
 		const isSelectStatement = /^\s*SELECT /i.test(sql);
 		if (isSelectStatement) {
-			const count = rows(await this._conn.raw(`SELECT count(1) AS count FROM (${sql.replace(/;\s*$/, "")}) AS x`, opt_args)).length;
+			const count = this._cassette.rows(await this._conn.raw(`SELECT count(1) AS count FROM (${sql.replace(/;\s*$/, "")}) AS x`, opt_args)).length;
 			if (count > (this._options.maxRows || 10000)) {
 				throw 'Too many records';
 			}
 		}
 
-		return rows(await this._conn.raw(sql, opt_args));
+		return this._cassette.rows(await this._conn.raw(sql, opt_args));
 	}
 
 	/**