type analysers for mysql, postgre

packages/engines/mssql/MsSqlAnalyser.js

@@ -4,7 +4,7 @@ const sql = require('./sql');
 
 const DatabaseAnalyser = require('../default/DatabaseAnalyser');
 const { filter } = require('lodash');
-const { isTypeString } = require('@dbgate/tools');
+const { isTypeString, isTypeNumeric } = require('@dbgate/tools');
 
 function objectTypeToField(type) {
   switch (type.trim()) {
@@ -25,9 +25,19 @@ function objectTypeToField(type) {
   }
 }
 
-function getColumnInfo({ isNullable, isIdentity, columnName, dataType, charMaxLength }) {
+function getColumnInfo({
+  isNullable,
+  isIdentity,
+  columnName,
+  dataType,
+  charMaxLength,
+  numericPrecision,
+  numericScale,
+}) {
   let fullDataType = dataType;
   if (charMaxLength && isTypeString(dataType)) fullDataType = `${dataType}(${charMaxLength})`;
+  if (numericPrecision && numericScale && isTypeNumeric(dataType))
+    fullDataType = `${dataType}(${numericPrecision},${numericScale})`;
   return {
     columnName,
     dataType: fullDataType,

packages/engines/mssql/sql/columns.js

@@ -4,6 +4,8 @@ select c.name as columnName, t.name as dataType, c.object_id as objectId, c.is_i
 	col.CHARACTER_MAXIMUM_LENGTH as charMaxLength,
 	d.definition as defaultValue, d.name as defaultConstraint,
 	m.definition as computedExpression, m.is_persisted as isPersisted, c.column_id as columnId, 
+	col.NUMERIC_PRECISION as numericPrecision,
+	col.NUMERIC_SCALE as numericScale,
 	-- TODO only if version >= 2008
 	c.is_sparse as isSparse
 from sys.columns c

packages/engines/mysql/MySqlAnalyser.js

@@ -3,6 +3,30 @@ const _ = require('lodash');
 const sql = require('./sql');
 
 const DatabaseAnalayser = require('../default/DatabaseAnalyser');
+const { isTypeString, isTypeNumeric } = require('@dbgate/tools');
+
+function getColumnInfo({
+  isNullable,
+  extra,
+  columnName,
+  dataType,
+  charMaxLength,
+  numericPrecision,
+  numericScale,
+  defaultValue,
+}) {
+  let fullDataType = dataType;
+  if (charMaxLength && isTypeString(dataType)) fullDataType = `${dataType}(${charMaxLength})`;
+  if (numericPrecision && numericScale && isTypeNumeric(dataType))
+    fullDataType = `${dataType}(${numericPrecision},${numericScale})`;
+  return {
+    notNull: !isNullable,
+    autoIncrement: extra && extra.toLowerCase().includes('auto_increment'),
+    columnName,
+    dataType: fullDataType,
+    defaultValue,
+  };
+}
 
 class MySqlAnalyser extends DatabaseAnalayser {
   constructor(pool, driver) {
@@ -24,13 +48,7 @@ class MySqlAnalyser extends DatabaseAnalayser {
     return this.mergeAnalyseResult({
       tables: tables.rows.map((table) => ({
         ...table,
-        columns: columns.rows
+        columns: columns.rows.filter((col) => col.pureName == table.pureName).map(getColumnInfo),
-          .filter((col) => col.pureName == table.pureName)
-          .map(({ isNullable, extra, ...col }) => ({
-            ...col,
-            notNull: !isNullable,
-            autoIncrement: extra && extra.toLowerCase().includes('auto_increment'),
-          })),
         primaryKey: DatabaseAnalayser.extractPrimaryKeys(table, pkColumns.rows),
         foreignKeys: DatabaseAnalayser.extractForeignKeys(table, fkColumns.rows),
       })),

packages/engines/mysql/sql/columns.js

@@ -4,10 +4,10 @@ select
 	COLUMN_NAME as columnName,
 	IS_NULLABLE as isNullable,
 	DATA_TYPE as dataType,
-	CHARACTER_MAXIMUM_LENGTH,
+	CHARACTER_MAXIMUM_LENGTH as charMaxLength,
-	NUMERIC_PRECISION,
+	NUMERIC_PRECISION as numericPrecision,
-	NUMERIC_SCALE,
+	NUMERIC_SCALE as numericScale,
-	COLUMN_DEFAULT,
+	COLUMN_DEFAULT as defaultValue,
 	EXTRA as extra
 from INFORMATION_SCHEMA.COLUMNS
 where TABLE_SCHEMA = '#DATABASE#' and TABLE_NAME =[OBJECT_NAME_CONDITION]

packages/engines/postgres/PostgreAnalyser.js

@@ -3,6 +3,37 @@ const _ = require('lodash');
 const sql = require('./sql');
 
 const DatabaseAnalayser = require('../default/DatabaseAnalyser');
+const { isTypeString, isTypeNumeric } = require('@dbgate/tools');
+
+function normalizeTypeName(dataType) {
+  if (dataType == 'character varying') return 'varchar';
+  if (dataType == 'timestamp without time zone') return 'timestamp';
+  return dataType;
+}
+
+function getColumnInfo({
+  isNullable,
+  isIdentity,
+  columnName,
+  dataType,
+  charMaxLength,
+  numericPrecision,
+  numericScale,
+  defaultValue,
+}) {
+  const normDataType = normalizeTypeName(dataType);
+  let fullDataType = normDataType;
+  if (charMaxLength && isTypeString(normDataType)) fullDataType = `${normDataType}(${charMaxLength})`;
+  if (numericPrecision && numericScale && isTypeNumeric(normDataType))
+    fullDataType = `${normDataType}(${numericPrecision},${numericScale})`;
+  return {
+    columnName,
+    dataType: fullDataType,
+    notNull: !isNullable,
+    autoIncrement: !!isIdentity,
+    defaultValue,
+  };
+}
 
 class PostgreAnalyser extends DatabaseAnalayser {
   constructor(pool, driver) {
@@ -26,10 +57,7 @@ class PostgreAnalyser extends DatabaseAnalayser {
         ...table,
         columns: columns.rows
           .filter((col) => col.pureName == table.pureName && col.schemaName == table.schemaName)
-          .map(({ isNullable, ...col }) => ({
+          .map(getColumnInfo),
-            ...col,
-            notNull: !isNullable,
-          })),
         primaryKey: DatabaseAnalayser.extractPrimaryKeys(table, pkColumns.rows),
         foreignKeys: DatabaseAnalayser.extractForeignKeys(table, fkColumns.rows),
       })),

packages/engines/postgres/sql/columns.js

@@ -4,11 +4,11 @@ select
 	table_name as "pureName", 
 	column_name as "columnName",
 	is_nullable as "isNullable",
-	data_type as dataType,
+	data_type as "dataType",
-	character_maximum_length,
+	character_maximum_length as "charMaxLength",
-	numeric_precision,
+	numeric_precision as "numericPrecision",
-	numeric_scale,
+	numeric_scale as "numericScale",
-	column_default
+	column_default as "defaultValue"
 from information_schema.columns
 where 
 		table_schema <> 'information_schema' 

packages/tools/src/commonTypeParser.ts

@@ -23,5 +23,5 @@ export function isTypeLogical(dataType) {
 }
 
 export function isTypeDateTime(dataType) {
-  return dataType && /date|time/i.test(dataType);
+  return dataType && /date|time|timestamp/i.test(dataType);
 }