@dbml/core 2.3.1 → 2.4.2

package/lib/parse/mssql/fk_definition/actions.js

@@ -2,9 +2,13 @@
 
 var _ = require('lodash');
 
+var _require = require('../utils'),
+    getFullTableName = _require.getFullTableName;
+
 function makeEndPoint(tableName, columnName, relation) {
   return {
-    tableName: tableName[tableName.length - 1],
+    tableName: tableName.name,
+    schemaName: tableName.schemaName,
     fieldNames: columnName,
     relation: relation
   };
@@ -24,7 +28,8 @@ function setOption(value, fkOptions) {
 
 function makeColumnConstraintFK(_unused, tableName, columnName, fkOptions) {
   var value = {};
-  value.endpoint = makeEndPoint(tableName, columnName, '1');
+  var fullTableName = getFullTableName(tableName);
+  value.endpoint = makeEndPoint(fullTableName, columnName, '1');
   setOption(value, fkOptions);
   return {
     type: 'inline_refs',
@@ -43,6 +48,7 @@ function makeTableEndpoint(columnNames) {
 
 function makeTableConstraintFK(_keyword1, endpoint1, _keyword2, tableName, endpoint2, fkOptions) {
   var value = {};
+  var fullTableName = getFullTableName(tableName);
 
   if (!endpoint2) {
     // eslint-disable-next-line no-param-reassign
@@ -55,7 +61,8 @@ function makeTableConstraintFK(_keyword1, endpoint1, _keyword2, tableName, endpo
 
   endpoint1.value.relation = '*';
   endpoint2.value.relation = '1';
-  endpoint2.value.tableName = _.last(tableName);
+  endpoint2.value.tableName = fullTableName.name;
+  endpoint2.value.schemaName = fullTableName.schemaName;
   value.endpoints = [endpoint1.value, endpoint2.value];
   setOption(value, fkOptions);
   return {

package/lib/parse/mssql/keyword_parsers.js

@@ -83,6 +83,7 @@ exports.KeywordCollate = keyword(/COLLATE/i);
 exports.KeywordClose = keyword(/CLOSE/i);
 exports.KeywordDeny = keyword(/DENY/i);
 exports.KeywordExecute = keyword(/EXECUTE/i);
+exports.KeywordExec = keyword(/EXEC/i);
 exports.KeywordGrant = keyword(/GRANT/i);
 exports.KeywordOpen = keyword(/OPEN/i);
 exports.KeywordRevoke = keyword(/REVOKE/i);
@@ -96,6 +97,7 @@ exports.KeywordSend = keyword(/SEND/i);
 exports.KeywordRename = keyword(/RENAME/i);
 exports.KeywordDelete = keyword(/DELETE/i);
 exports.KeywordIf = keyword(/IF/i);
+exports.KeywordSP_ADDEXTENDEDPROPERTY = keyword(/sp_addextendedproperty/i);
 exports.LogicalOpIn = keyword(/IN/i);
 exports.LogicalOpAnd = keyword(/AND/i);
 exports.LessThan = word('<');
@@ -104,7 +106,16 @@ exports.LParen = word('(');
 exports.Comma = word(',');
 exports.RParen = word(')');
 exports.DoubleQuote = word('"');
+exports.SingleQuote = word('\'');
 exports.LBracket = word('[');
 exports.RBracket = word(']');
 exports.Equal = word('=');
-exports.Semicolon = word(';');
+exports.Semicolon = word(';');
+exports.KeywordAtName = keyword(/@name/i);
+exports.KeywordAtValue = keyword(/@value/i);
+exports.KeywordAtLevel0Type = keyword(/@level0type/i);
+exports.KeywordAtLevel0Name = keyword(/@level0name/i);
+exports.KeywordAtLevel1Type = keyword(/@level1type/i);
+exports.KeywordAtLevel1Name = keyword(/@level1name/i);
+exports.KeywordAtLevel2Type = keyword(/@level2type/i);
+exports.KeywordAtLevel2Name = keyword(/@level2name/i);

package/lib/parse/mssql/statements/actions.js

@@ -2,10 +2,13 @@
 
 var _ = require('lodash');
 
-function findTable(ast, tableName) {
-  return ast.tables.find(function (_table) {
-    return _table.name === tableName;
+function findTable(ast, tableName, schemaName) {
+  var realSchemaName = schemaName || 'public';
+  var table = ast.tables.find(function (t) {
+    var targetSchemaName = t.schemaName || 'public';
+    return targetSchemaName === realSchemaName && t.name === tableName;
   });
+  return table;
 }
 
 function findField(table, fieldName) {
@@ -15,7 +18,7 @@ function findField(table, fieldName) {
 }
 
 function handleIndexes(index, ast) {
-  var table = findTable(ast, index.tableName);
+  var table = findTable(ast, index.tableName, index.schemaName);
   table.indexes.push(index);
   index.tableName = null;
 }
@@ -37,7 +40,7 @@ function handleTable(table, ast) {
 }
 
 function handleDefaults(dbdefault, ast) {
-  var table = findTable(ast, dbdefault.tableName);
+  var table = findTable(ast, dbdefault.tableName, dbdefault.schemaName);
   var field = findField(table, dbdefault.fieldName);
   dbdefault.fieldName = null;
   dbdefault.tableName = null;
@@ -45,7 +48,7 @@ function handleDefaults(dbdefault, ast) {
 }
 
 function handleEnums(_enum, ast) {
-  var table = findTable(ast, _enum.tableName);
+  var table = findTable(ast, _enum.tableName, _enum.schemaName);
   var field = findField(table, _enum.fieldName);
   _enum.name = "".concat(_enum.tableName, "_").concat(_enum.fieldName, "_enum");
   _enum.fieldName = null;
@@ -56,6 +59,30 @@ function handleEnums(_enum, ast) {
   }).join(', ');
 }
 
+function handleComment(comment, ast) {
+  if (comment.type === 'table') handleTableNote(comment, ast);else if (comment.type === 'column') handleFieldNote(comment, ast);
+}
+
+function handleTableNote(comment, ast) {
+  var schemaName = comment.schemaName;
+  if (schemaName === 'dbo') schemaName = null; // treat `dbo` as public schema
+
+  var foundTable = findTable(ast, comment.tableName, schemaName);
+  if (foundTable) foundTable.note = comment.note;
+}
+
+function handleFieldNote(comment, ast) {
+  var schemaName = comment.schemaName;
+  if (schemaName === 'dbo') schemaName = null; // treat `dbo` as public schema
+
+  var foundTable = findTable(ast, comment.tableName, schemaName);
+
+  if (foundTable) {
+    var foundField = findField(foundTable, comment.columnName);
+    if (foundField) foundField.note = comment.note;
+  }
+}
+
 function handleStatement(_statements) {
   var ast = {
     tables: [],
@@ -87,6 +114,10 @@ function handleStatement(_statements) {
         handleEnums(statement.value, ast);
         break;
 
+      case 'comment':
+        handleComment(statement.value, ast);
+        break;
+
       default:
         break;
     }

package/lib/parse/mssql/statements/index.js

@@ -18,7 +18,7 @@ var Lang = P.createLanguage({
     return wss.then(r.Seperator).then(P.sepBy(r.StatementTypes, r.Seperator)).skip(r.Seperator).map(A.handleStatement);
   },
   StatementTypes: function StatementTypes(r) {
-    return P.alt(S.pCreateIndex, S.pCreateTable, S.pAlterTable, r.IgnoredStatementTypes);
+    return P.alt(S.pCreateIndex, S.pCreateTable, S.pAlterTable, S.pCommentSyntax, r.IgnoredStatementTypes);
   },
   IgnoredStatementTypes: function IgnoredStatementTypes(r) {
     return P.seq(r.IgnoredStatementSyntax, pIgnore);

package/lib/parse/mssql/statements/statement_types/alter_table/actions.js

@@ -2,31 +2,37 @@
 
 var _ = require('lodash');
 
+var _require = require('../../../utils'),
+    getFullTableName = _require.getFullTableName;
+
 function handleRef(tableName, result) {
   var endpointWithNoTableName = result.value.endpoints.find(function (ele) {
     return !ele.tableName;
   });
-  endpointWithNoTableName.tableName = _.last(tableName);
+  endpointWithNoTableName.tableName = tableName.name;
+  endpointWithNoTableName.schemaName = tableName.schemaName;
 }
 
 function addTableName(tableName, result) {
-  result.value.tableName = _.last(tableName);
+  result.value.tableName = tableName.name;
+  result.value.schemaName = tableName.schemaName;
 }
 
 function handleAlterTableResult(_keyword, tableName, results) {
-  if (!results) return null; // eslint-disable-next-line consistent-return
+  if (!results) return null;
+  var fullName = getFullTableName(tableName); // eslint-disable-next-line consistent-return
 
   results.forEach(function (result) {
     if (result) {
       switch (result.type) {
         case 'refs':
-          handleRef(tableName, result);
+          handleRef(fullName, result);
           break;
 
         case 'indexes':
         case 'dbdefault':
         case 'enums':
-          addTableName(tableName, result);
+          addTableName(fullName, result);
           break;
 
         default:

package/lib/parse/mssql/statements/statement_types/comments/actions.js

@@ -0,0 +1,57 @@
+"use strict";
+
+function handleComment(_ref) {
+  var note = _ref.note,
+      level = _ref.level;
+  var type = 'unsupported';
+  var schemaName = null,
+      tableName = null,
+      columnName = null;
+
+  if (isValidTableNote(level)) {
+    schemaName = level[0].name;
+    tableName = level[1].name; // Table Comment
+
+    type = 'table';
+  } else if (isValidColumnNote(level)) {
+    schemaName = level[0].name;
+    tableName = level[1].name;
+    columnName = level[2].name;
+    type = 'column';
+  }
+
+  return {
+    type: 'comment',
+    value: {
+      type: type,
+      note: note,
+      schemaName: schemaName,
+      tableName: tableName,
+      columnName: columnName
+    }
+  };
+}
+
+var isSchema = function isSchema(type) {
+  return type.toLowerCase() === 'schema';
+};
+
+var isTable = function isTable(type) {
+  return type.toLowerCase() === 'table';
+};
+
+var isColumn = function isColumn(type) {
+  return type.toLowerCase() === 'column';
+};
+
+var isValidTableNote = function isValidTableNote(level) {
+  return level.length === 2 && isSchema(level[0].type) && isTable(level[1].type);
+};
+
+var isValidColumnNote = function isValidColumnNote(level) {
+  return level.length === 3 && isSchema(level[0].type) && isTable(level[1].type) && isColumn(level[2].type);
+};
+
+module.exports = {
+  handleComment: handleComment
+};

package/lib/parse/mssql/statements/statement_types/comments/index.js

@@ -0,0 +1,97 @@
+"use strict";
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var P = require('parsimmon');
+
+var KP = require('../../../keyword_parsers');
+
+var A = require('./actions');
+
+var _require = require('../../../utils'),
+    makeNode = _require.makeNode;
+
+var Lang = P.createLanguage({
+  StartComment: function StartComment() {
+    return P.seq(KP.KeywordExec, KP.KeywordSP_ADDEXTENDEDPROPERTY);
+  },
+  EndComment: function EndComment() {
+    return P.seq(KP.Semicolon.atMost(1), KP.KeywordGo);
+  },
+  StartString: function StartString() {
+    return P.alt(KP.SingleQuote, P.string("N'"));
+  },
+  ManyDoubleSingleQuote: function ManyDoubleSingleQuote() {
+    return P.string("''");
+  },
+  NoSingleQuote: function NoSingleQuote() {
+    return P.regex(/[^']/);
+  },
+  StringType: function StringType(r) {
+    return P.alt(r.NoSingleQuote, r.ManyDoubleSingleQuote).atLeast(1).map(function (res) {
+      return res.join('');
+    });
+  },
+  NVarchar: function NVarchar(r) {
+    return r.StartString.then(r.StringType).skip(KP.SingleQuote);
+  },
+  NameOption: function NameOption(r) {
+    return KP.KeywordAtName.skip(KP.Equal).then(r.NVarchar);
+  },
+  ValueOption: function ValueOption(r) {
+    return KP.KeywordAtValue.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level0Type: function Level0Type(r) {
+    return KP.KeywordAtLevel0Type.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level0Name: function Level0Name(r) {
+    return KP.KeywordAtLevel0Name.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level1Type: function Level1Type(r) {
+    return KP.KeywordAtLevel1Type.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level1Name: function Level1Name(r) {
+    return KP.KeywordAtLevel1Name.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level2Type: function Level2Type(r) {
+    return KP.KeywordAtLevel2Type.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level2Name: function Level2Name(r) {
+    return KP.KeywordAtLevel2Name.skip(KP.Equal).then(r.NVarchar);
+  },
+  Level0Stmt: function Level0Stmt(r) {
+    return P.seqObj(['type', r.Level0Type], KP.Comma, ['name', r.Level0Name]);
+  },
+  Level1Stmt: function Level1Stmt(r) {
+    return P.seqObj(['type', r.Level1Type], KP.Comma, ['name', r.Level1Name]);
+  },
+  Level2Stmt: function Level2Stmt(r) {
+    return P.seqObj(['type', r.Level2Type], KP.Comma, ['name', r.Level2Name]);
+  },
+  Level0Wrapper: function Level0Wrapper(r) {
+    return P.alt(P.seq(r.Level0Stmt.skip(KP.Comma), r.Level1Wrapper), r.Level0Stmt).map(function (res) {
+      return Array.isArray(res) ? [res[0]].concat(_toConsumableArray(res[1])) : [res];
+    }).atMost(1).map(function (res) {
+      return res.length === 1 ? res[0] : res;
+    });
+  },
+  Level1Wrapper: function Level1Wrapper(r) {
+    return P.alt(P.seq(r.Level1Stmt.skip(KP.Comma), r.Level2Stmt), r.Level1Stmt).map(function (res) {
+      return Array.isArray(res) ? res : [res];
+    });
+  },
+  CommentSyntax: function CommentSyntax(r) {
+    return P.seqObj(r.StartComment, ['name', r.NameOption], KP.Comma, ['note', r.ValueOption], KP.Comma, ['level', r.Level0Wrapper], r.EndComment).map(A.handleComment).thru(makeNode());
+  }
+});
+module.exports = Lang.CommentSyntax;

package/lib/parse/mssql/statements/statement_types/create_index/actions.js

@@ -1,6 +1,10 @@
 "use strict";
 
+var _require = require('../../../utils'),
+    getFullTableName = _require.getFullTableName;
+
 function makeIndex(_create, isUnique, _clustered, _index, indexName, _on, tableName, columnNames) {
+  var fullTableName = getFullTableName(tableName);
   var columns = [];
   columnNames.forEach(function (columnName) {
     columns.push({
@@ -13,7 +17,8 @@ function makeIndex(_create, isUnique, _clustered, _index, indexName, _on, tableN
     value: {
       name: indexName,
       unique: isUnique ? true : null,
-      tableName: tableName[tableName.length - 1],
+      tableName: fullTableName.name,
+      schemaName: fullTableName.schemaName,
       columns: columns
     }
   };

package/lib/parse/mssql/statements/statement_types/create_table/actions.js

@@ -8,6 +8,9 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 var _ = require('lodash');
 
+var _require = require('../../../utils'),
+    getFullTableName = _require.getFullTableName;
+
 function createRefFromInlineRef(linesRefs, inlineRefs, fieldName, tableName) {
   if (!inlineRefs || inlineRefs.length === 0) return;
   var newRef = {};
@@ -16,7 +19,8 @@ function createRefFromInlineRef(linesRefs, inlineRefs, fieldName, tableName) {
   newRef.onDelete = inlineRef.onDelete;
   newRef.endpoints = [];
   newRef.endpoints.push({
-    tableName: tableName,
+    tableName: tableName.name,
+    schemaName: tableName.schemaName,
     fieldNames: [fieldName],
     relation: '*'
   });
@@ -33,7 +37,7 @@ function pushOutEnum(linesEnums, fieldValue, tableName) {
   if (fieldValue.enums) {
     var _enum = fieldValue.enums;
     var fieldType = fieldValue.type;
-    _enum.name = "".concat(tableName, "_").concat(fieldValue.enums.name);
+    _enum.name = "".concat(tableName.schemaName ? "".concat(tableName.schemaName, "_") : '').concat(tableName.name, "_").concat(fieldValue.enums.name);
     fieldType.type_name = _enum.name;
     fieldType.args = _enum.values.map(function (value) {
       return "'".concat(value.name, "'");
@@ -71,7 +75,8 @@ function getLinesValue(lines, tableName) {
 
       if (line.type === 'refs') {
         var ref = line.value;
-        ref.endpoints[0].tableName = tableName;
+        ref.endpoints[0].tableName = tableName.name;
+        ref.endpoints[0].schemaName = tableName.schemaName;
       }
 
       value[line.type].push(line.value);
@@ -84,14 +89,11 @@ function getLinesValue(lines, tableName) {
 }
 
 function makeTable(_keyword, tableName, _keyword2, lines) {
-  var linesValue = getLinesValue(lines, _.last(tableName));
+  var fullName = getFullTableName(tableName);
+  var linesValue = getLinesValue(lines, fullName);
   return {
     type: 'tables',
-    value: _objectSpread(_objectSpread({
-      name: _.last(tableName)
-    }, linesValue.value), {}, {
-      schemaName: tableName.length > 1 ? tableName[tableName.length - 2] : null
-    })
+    value: _objectSpread(_objectSpread({}, fullName), linesValue.value)
   };
 }
 

package/lib/parse/mssql/statements/statement_types/index.js

@@ -6,8 +6,11 @@ var pCreateIndex = require('./create_index/index');
 
 var pCreateTable = require('./create_table');
 
+var pCommentSyntax = require('./comments');
+
 module.exports = {
   pAlterTable: pAlterTable,
   pCreateIndex: pCreateIndex,
-  pCreateTable: pCreateTable
+  pCreateTable: pCreateTable,
+  pCommentSyntax: pCommentSyntax
 };

package/lib/parse/mssql/utils.js

@@ -4,6 +4,8 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
 
 var P = require('parsimmon');
 
+var _ = require('lodash');
+
 var _require = require('./keyword_parsers'),
     LParen = _require.LParen,
     RParen = _require.RParen,
@@ -47,4 +49,17 @@ exports.streamline = function (type) {
       };
     });
   };
+};
+
+exports.getFullTableName = function (nameList) {
+  var schemaName = null;
+
+  if (nameList.length > 1) {
+    schemaName = nameList[nameList.length - 2];
+  }
+
+  return {
+    name: _.last(nameList),
+    schemaName: schemaName
+  };
 };

package/lib/parse/mysql/parser.pegjs

@@ -4,6 +4,15 @@
 	const refs = [];
 	const enums = [];
 
+  // TODO: support configurable default schema name other than 'public'
+  const findTable = (schemaName, tableName) => {
+    const realSchemaName = schemaName || 'public';
+    const table = tables.find(table => {
+      const targetSchemaName = table.schemaName || 'public';
+      return targetSchemaName === realSchemaName && table.name === tableName;
+    });
+    return table;
+  };
   // intput:
   // ` 
   //      'created'
@@ -25,20 +34,20 @@ Rule = (Expr)* {
   return {tables, refs, enums};
 }
 
-Expr = 
+Expr =
 	t:TableSyntax { tables.push(t) }
 	/AlterSyntax
 	/IndexSyntax
 	/IgnoreSyntax
 	/__
-    
+
 // 				TableSyntax: support "CREATE TABLE" syntax.
 // Try to support as mush as possible syntax in MySQL offical documents.
 // https://dev.mysql.com/doc/refman/8.0/en/create-table.html
-// Return: table object: {name, fields, [,indexes]}
-TableSyntax 
-	= create_table (__ if_not_exist)? __ name:table_name _ 
-    "(" _ body:TableBody _ ")" _ TableOptions? _ semicolon endline?
+// Return: table object: {name, schemaName, fields, [,indexes]}
+TableSyntax
+	= create_table (__ if_not_exist)? __ table_name:table_name _
+    "(" _ body:TableBody _ ")" _ options:TableOptions? _ semicolon endline?
 {
 	const fields = body.fields;
 	const indexes = body.indexes;
@@ -59,7 +68,8 @@ TableSyntax
 			});
 
 			const _enum = {
-				name: `${name}_${field.name}_enum`,
+				name: `${table_name.schemaName
+				? `${table_name.schemaName}_` : ''}${table_name.name}_${field.name}_enum`,
 				values
 			};
 			enums.push(_enum);
@@ -68,15 +78,18 @@ TableSyntax
     });
 
 	bodyRefs.forEach(ref => {
-		ref.endpoints[0].tableName = name;
+		ref.endpoints[0].tableName = table_name.name;
+		ref.endpoints[0].schemaName = table_name.schemaName;
 		ref.endpoints[0].relation = '*';
 		refs.push(ref);
 	});
 
-    // return statement
-    return indexes ? 
-    	{name, fields, indexes} 
-      : {name, fields}
+  let res = {...table_name, fields};
+
+	if (options && options.comment) res.note = options.comment;
+	if (indexes) res.indexes = indexes;
+	// return statement
+	return res;
 }
 
 // TableBody: this is the part between parenthesis.
@@ -149,7 +162,8 @@ FKSyntax = _ constraint:("CONSTRAINT"i _ name)? _ foreign_key _
 				relation: "*",
 			},
 			{
-				tableName: table2,
+				tableName: table2.name,
+				schemaName: table2.schemaName,
 				fieldNames: fields2,
 				relation: "1",
 			}
@@ -295,16 +309,19 @@ CheckConstraintSyntax = _ ("CONSTRAINT"i name _)? "CHECK"i _ expression _ ("NOT"
 // 			AlterSyntax: support "ALTER TABLE" syntax
 // We will support ADD_COLUMN, ADD_FOREIGN_KEY, ADD_INDEX
 // https://dev.mysql.com/doc/refman/8.0/en/alter-table.html
-AlterSyntax = alter_table _ table:name _ 
+AlterSyntax = alter_table _ table:table_name _ 
 	options:(AddOptions/ChangeOptions/DropOptions) _
   semicolon
 {
 	const fks = _.flatten(options.filter(o => o.type === "add_fk").map(o => o.fks));
-	fks.forEach(fk => {fk.endpoints[0].tableName = table});
+	fks.forEach(fk => {
+		fk.endpoints[0].tableName = table.name;
+		fk.endpoints[0].schemaName = table.schemaName;
+	});
 	refs.push(...fks)
 
 	const pks = _.flatten(options.filter(o => o.type === "add_pk").map(o => o.pks));
-	const tableAlter = tables.find((t) => t.name === table);
+	const tableAlter = findTable(table.schemaName, table.name);
 	
 	const index = {
 		columns: pks.map(field => ({
@@ -341,7 +358,7 @@ DropOptions = "DROP"i [^;]
 
 // 			IndexSyntax: support "CREATE INDEX" syntax
 IndexSyntax = constraint:create_index _ indexName:name _
-	"ON"i _ tableName:name _ indexType:index_type? _
+	"ON"i _ tableName:table_name _ indexType:index_type? _
 	columns: IndexColumn _
 	option:IndexOption? semicolon
 {
@@ -358,7 +375,8 @@ IndexSyntax = constraint:create_index _ indexName:name _
 	if(type) 
 		index.type = type;
 
-	const table = tables.find(table => table.name === tableName);
+	const table = findTable(tableName.schemaName, tableName.name);
+
 	if(table.indexes) {
 		table.indexes.push(index);
 	} else {
@@ -400,6 +418,7 @@ IgnoreSyntax
 	/ BeginSyntax
 	/ CommitSyntax
 	/ RollbackSyntax
+	/ "ALTER"i _ (comment / !(semicolon) .)*
 	) semicolon newline?
 
 // InsertSyntax: "INSERTO INTO" syntax
@@ -458,8 +477,24 @@ index_type "index type" = "USING"i _ type:("BTREE"i/"HASH"i) { return type.toUpp
 name "valid name"
   = c:(character)+ { return c.join("") }
   / quote c:[^`]+ quote { return c.join("") }
-table_name "valid table name"
-  = (name _ "." _)* name:name { return name }
+
+path_name = names:(name _ "." _)* {
+  let dbName = null;
+  let schemaName = null;
+  if (names && names.length > 0) {
+    if (names.length === 1) schemaName = names[0][0];
+    else {
+      dbName = names[0][0];
+      schemaName = names[1][0];
+    }
+  }
+  return { dbName, schemaName }
+}
+
+table_name "valid table name" = pathName:path_name name:name {
+  return { ...pathName, name }
+}
+
 type "type" = c:type_name { return c }
 	/  c:name { return { type_name: c } }
 type_name = type_name:name _ args:("(" _ expression _ ")")? {