extract-mysql-schema 0.4.0 → 0.6.0

package/index.js

@@ -68,25 +68,37 @@ const extractSchemas = async function (connection, options) {
     queryFkey=queryFkey[0];
 
     let queryIndexes = await adapter.query(`
-    select T2.TABLE_SCHEMA,T2.TABLE_NAME,I.NAME as INDEX_NAME,F.NAME AS FIELD_NAME,F.POS,
-    CASE WHEN I.TYPE=2 OR I.TYPE=3 THEN 'YES' ELSE 'NO' END AS IS_UNIQUE,
-    CASE WHEN I.TYPE=3 THEN 'YES' ELSE 'NO' END AS IS_PRIMARY,
-    CASE WHEN I.TYPE=0 THEN 'YES' ELSE 'NO' END AS IS_FK
-    from INFORMATION_SCHEMA.INNODB_INDEXES I
+    select
+        T2.TABLE_SCHEMA,T2.TABLE_NAME,I.NAME as INDEX_NAME,
+        C.COLUMN_TYPE as FIELD_TYPE,
+        F.POS,I.TYPE,I.*,
+        CASE WHEN I.TYPE=2 OR I.TYPE=3 THEN 'YES' ELSE 'NO' END AS IS_UNIQUE,
+        CASE WHEN I.TYPE=3 THEN 'YES' ELSE 'NO' END AS IS_PRIMARY,
+        CASE WHEN I.TYPE=0 THEN 'YES' ELSE 'NO' END AS IS_FK,
+        CASE WHEN C.EXTRA='auto_increment' THEN 'YES' ELSE 'NO' END AS IS_AUTONUMBER,
+        F2.INDEX_KEYS as FIELD_NAME
+    FROM INFORMATION_SCHEMA.INNODB_INDEXES I
     JOIN INFORMATION_SCHEMA.INNODB_FIELDS F on F.INDEX_ID=I.INDEX_ID
+    JOIN (
+        SELECT group_concat(FF.NAME) as INDEX_KEYS,FF.INDEX_ID
+        FROM INFORMATION_SCHEMA.INNODB_FIELDS as FF
+        GROUP BY FF.INDEX_ID
+    ) as F2 ON F2.INDEX_ID=F.INDEX_ID
     JOIN INFORMATION_SCHEMA.INNODB_TABLES T1 ON T1.TABLE_ID=I.TABLE_ID
     LEFT JOIN INFORMATION_SCHEMA.TABLES T2 ON T1.NAME=CONCAT(T2.TABLE_SCHEMA,'/',T2.TABLE_NAME)
-    WHERE T2.TABLE_SCHEMA = '${schemaName}'
+    JOIN information_schema.COLUMNS C on C.TABLE_SCHEMA=T2.TABLE_SCHEMA and C.TABLE_NAME=T2.TABLE_NAME and C.COLUMN_NAME=F.NAME
+    WHERE T2.TABLE_SCHEMA = 'litservices' and F.POS=0
     ORDER BY T2.TABLE_SCHEMA,T2.TABLE_NAME,I.NAME,F.POS
     `);
     queryIndexes=queryIndexes[0];
 
     let queryColumns = await adapter.query(`
-    SELECT T.TABLE_TYPE,C.*
+    SELECT T.TABLE_TYPE,C.*,
+    CASE WHEN EXISTS(SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS C2 WHERE C2.TABLE_SCHEMA=C.TABLE_SCHEMA and C2.TABLE_NAME=C.TABLE_NAME AND C2.COLUMN_KEY='PRI' AND C.COLUMN_KEY='PRI' AND C2.COLUMN_NAME<>C.COLUMN_NAME) THEN 'YES' ELSE 'NO' END AS IS_COMPOUND_KEY
     FROM INFORMATION_SCHEMA.COLUMNS C
     LEFT JOIN INFORMATION_SCHEMA.TABLES T ON T.TABLE_SCHEMA=C.TABLE_SCHEMA AND T.TABLE_NAME=C.TABLE_NAME
     where C.TABLE_SCHEMA ='${schemaName}'
-    ORDER BY C.TABLE_NAME,C.ORDINAL_POSITION
+    order by C.TABLE_NAME,C.ORDINAL_POSITION
     `);
     queryColumns = queryColumns[0];
 
@@ -166,6 +178,7 @@ const extractSchemas = async function (connection, options) {
             sqltype: queryColumns[i]['COLUMN_TYPE'],
             maxLength: queryColumns[i]['CHARACTER_MAXIMUM_LENGTH'],
             isPrimaryKey: queryColumns[i]['COLUMN_KEY'] === 'PRI',
+            isCompoundKey: queryColumns[i]['IS_COMPOUND_KEY'] === 'YES',
             isNullable: queryColumns[i]['IS_NULLABLE'] === 'YES',
             isAutoNumber: queryColumns[i]['EXTRA'] === 'auto_increment',
             generated: queryColumns[i]['EXTRA'].indexOf('DEFAULT_GENERATED') >= 0 ? (queryColumns[i]['EXTRA'].indexOf('on update') > 0 ? "ALWAYS" : "BY DEFAULT") : "NEVER",
@@ -179,10 +192,13 @@ const extractSchemas = async function (connection, options) {
         let def = column.defaultValue?(column.defaultValue):"";
         if(def!=="CURRENT_TIMESTAMP" && def) {
             if(def.indexOf('(')>0) def=`(${def})`;
-            else if(column.type.indexOf('char')>=0 || column.type.indexOf('text')>=0) def=`'${def}'`;
+            else if(column.type.indexOf('char')>=0 || column.type.indexOf('text')>=0) {
+                if(def.indexOf("'")>=0) def='('+def.replace(/\\'/g,"'")+')';
+                else def=`('${def}')`;
+            }
         }
         if(def) def=`DEFAULT ${def}`;
-        definition.push(`${name}\t${column.sqltype}\t${column.isAutoNumber?" auto_increment":""}${def}\t${column.isNullable?"NULL":"NOT NULL"}${column.isPrimaryKey?" PRIMARY KEY":""}${extra}`);
+        definition.push(`${name}\t${column.sqltype}\t${column.isAutoNumber && column.isPrimaryKey ?" auto_increment":""}${def}\t${column.isNullable?"NULL":"NOT NULL"}${column.isPrimaryKey && !column.isCompoundKey?" PRIMARY KEY":""}${extra}`);
 
         if(foreign[tableName+"_"+name]!==undefined) {
             column.references.push(foreign[tableName+"_"+name]);
@@ -208,75 +224,62 @@ const extractSchemas = async function (connection, options) {
             let isConstraint = idx['IS_UNIQUE']==='YES' || idx['IS_PRIMARY']==='YES' || idx['IS_FK']==='YES';
 
             if(isConstraint) {
-                if(idx['IS_PRIMARY']==='YES') return;
-                else if(idx['IS_UNIQUE']==='YES') {
-                    definitions.push(`
+                if(idx['IS_PRIMARY']==='YES') {
+                    if(idx['FIELD_NAME'].indexOf(',')>0) {
+                        definitions.push(`
 alter table ${idx['TABLE_NAME']}
-    add constraint ${idx['INDEX_NAME']}
-        unique (${idx['FIELD_NAME']});
+    add primary key (${idx['FIELD_NAME']});
 `)
-                } else {
-                    let ref = foreign[name+"_"+idx['FIELD_NAME']];
-                    //console.log("HERE",name+"_"+idx['FIELD_NAME'],ref);
-                    if(ref===undefined) return;
-
+                    }
+                } else if(idx['IS_UNIQUE']==='YES') {
                     definitions.push(`
 alter table ${idx['TABLE_NAME']}
     add constraint ${idx['INDEX_NAME']}
-        foreign key (${idx['FIELD_NAME']}) references ${ref['tableName']} (${ref['columnName']});
+    unique (${idx['FIELD_NAME']});
 `)
+                    if(idx['IS_AUTONUMBER']==='YES') {
+                        definitions.push(`
+alter table ${idx['TABLE_NAME']}
+    modify ${idx['FIELD_NAME']} ${idx['FIELD_TYPE']} auto_increment;`);
+definitions.push(`
+alter table ${idx['TABLE_NAME']}
+    auto_increment = 1;`);
+                    }
                 }
             } else {
                 definitions.push(`
 create index ${idx['INDEX_NAME']}
-    on ${idx['TABLE_NAME']} (${idx['FIELD_NAME']});
-`)
+    on ${idx['TABLE_NAME']} (${idx['FIELD_NAME']});`)
             }
         });
 
         wrapper.definition = definitions.join('\n');
-       // if(name==="application") console.log(wrapper.definition);
     });
 
-    let noparent = [];
+    let tableOrder = [];
     for (let i = 0; i < tables.length; i++) {
         if(hasParent.indexOf(tables[i].name)<0) {
-            noparent.push(tables[i].name);
-        }
-    }
-    noparent.sort();
-
-    let byCounts = {};
-    for (let i = 0; i < hasParent.length; i++) {
-        let tableName = hasParent[i];
-        let table = schema[hasParent[i]];
-        for (let j = 0; j < table.length; j++) {
-            var column = table[j];
-            var references = column.references;
-            if(column.references.length==0) continue;
-
-            for (let k = 0; k < references.length; k++) {
-                var reference = references[k];
-                if(byCounts[reference.tableName]===undefined) byCounts[reference.tableName]={name:reference.tableName,count:0,children:[]};
-                byCounts[reference.tableName].count++;
-                byCounts[reference.tableName].children.push(tableName);
-            }
+            tableOrder.push(tables[i].name);
         }
     }
-    byCounts = orderBy(byCounts,['count']).reverse();
-    let tableOrder = noparent;
-    for(let i=0;i<byCounts.length;i++){
-        if(tableOrder.indexOf(byCounts[i].name)<0)
-            tableOrder.push(byCounts[i].name);
-
-        let children = byCounts[i].children;
-        for(let j=0;j<children.length;j++){
-            let child=children[j];
-            if(tableOrder.indexOf(child)<0 && byCounts.indexOf(child)<0) {
-                tableOrder.push(child);
-            }
+    tableOrder.sort();
+
+    hasParent.forEach((child)=>{
+        let tableColumns = schema[child];
+        let pos=-1;
+        tableColumns.forEach((column)=>{
+            column.references.forEach((reference)=>{
+                let pos2 = tableOrder.indexOf(reference.tableName);
+                //console.log(child,reference.tableName,pos,pos2);
+                if(pos2<0) { if(tableOrder.indexOf(reference.tableName)<0) { tableOrder.push(reference.tableName); } }
+                else if(pos2+1>pos) pos=pos2+1;
+            });
+        });
+        if(tableOrder.indexOf(child)<0) {
+            if(pos<0) tableOrder.push(child);
+            else tableOrder.splice(pos,0,child);
         }
-    }
+    });
 
     const procedures = [];
     for(let i=0;i<queryProcedures.length;i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "extract-mysql-schema",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "",
   "main": "index.js",
   "bin": "./run.js",

package/run.js

@@ -7,53 +7,75 @@ async function main(options) {
   const result = await extractSchemas(config.connection,options);
 
   if(options.writeSql){
-
+    const done = [];
     const content = [];
+    const processFolder = function(seedPath) {
+      if(fs.existsSync(seedPath)) {
+        fs.readdirSync(seedPath).forEach(file => {
+          file = path.join(seedPath,file);
+          if(done.indexOf(file)<0){
+            content.push(fs.readFileSync(file,"utf8"));
+          }
+        });
+      }
+    };
+
+    const tablesPath=path.join(process.cwd(),"tables");
     if(result[config.connection.database].tables.length>0) {
       // write table sql
-      const tablesPath=path.join(process.cwd(),"tables")
       if (!fs.existsSync(tablesPath)){
         fs.mkdirSync(tablesPath);
       }
       const byName = {};
       result[config.connection.database].tables.forEach(table => {
         byName[table.name] = table.definition;
-        if(options.verbose) console.log("writing",path.join(tablesPath,table.name+".sql"));
-        fs.writeFileSync(path.join(tablesPath,table.name+".sql"), table.definition ,"utf8")
+        let file = path.join(tablesPath,table.name+".sql");
+        done.push(file);
+        if(options.verbose) console.log("writing",file);
+        fs.writeFileSync(file, table.definition ,"utf8")
       });
 
       result[config.connection.database].tableOrder.forEach(table => {
         content.push(byName[table]);
       })
     }
+    processFolder(tablesPath);
 
+    const proceduresPath=path.join(process.cwd(),"procedures");
     if(result[config.connection.database].procedures.length>0) {
       // write routines
-      const proceduresPath=path.join(process.cwd(),"procedures")
       if (!fs.existsSync(proceduresPath)){
         fs.mkdirSync(proceduresPath);
       }
       result[config.connection.database].procedures.forEach(proc => {
-        if(options.verbose) console.log("writing",path.join(proceduresPath,proc.name+".sql"));
+        let file = path.join(proceduresPath,proc.name+".sql");
+        done.push(file);
+        if(options.verbose) console.log("writing",file);
         content.push(proc.definition);
-        fs.writeFileSync(path.join(proceduresPath,proc.name+".sql"), proc.definition ,"utf8")
+        fs.writeFileSync(file, proc.definition ,"utf8")
+      });
+    }
+    processFolder(proceduresPath);
+
+    const seedPath = path.join(process.cwd(),"seed");
+    if(fs.existsSync(seedPath)) {
+      result[config.connection.database].tableOrder.forEach(table => {
+        let seedfile = path.join(seedPath,table+'.sql');
+        if (fs.existsSync(seedfile)){
+          done.push(seedfile);
+          content.push(fs.readFileSync(seedfile,"utf8"));
+        }
       });
     }
+    processFolder(seedPath);
+
+    processFolder(path.join(process.cwd(),"override"));
 
     if(content.length>0) {
       fs.writeFileSync(path.join(process.cwd(),"init.sql"), content.join('\n\n') ,"utf8");
     }
   }
 
-  const seedList = [];
-  result[config.connection.database].tableOrder.forEach(table => {
-    let seedfile = path.join(process.cwd(),"seed",table+'.sql');
-    seedList.push(seedfile);
-    if (!fs.existsSync(seedfile)){
-      content.push(fs.readFileSync(seedfile,"utf8"));
-    }
-  })
-
   if(options.outputFile) {
     fs.writeFileSync(path.join(process.cwd(),options.outputFile), JSON.stringify(result,null,2) ,"utf8")
   } else console.log(JSON.stringify(result,null,2));