@dbml/core 3.11.0 → 3.12.0

package/lib/parse/ANTLR/ASTGeneration/mysql/MySQLASTGen.js

@@ -77,7 +77,8 @@ var MySQLASTGen = /*#__PURE__*/function (_MySQLParserVisitor) {
       enums: [],
       tableGroups: [],
       aliases: [],
-      project: {}
+      project: {},
+      records: []
     };
     return _this;
   }
@@ -119,6 +120,10 @@ var MySQLASTGen = /*#__PURE__*/function (_MySQLParserVisitor) {
     value: function visitSqlStatement(ctx) {
       if (ctx.ddlStatement()) {
         ctx.ddlStatement().accept(this);
+        return;
+      }
+      if (ctx.dmlStatement()) {
+        ctx.dmlStatement().accept(this);
       }
     }
 
@@ -216,7 +221,7 @@ var MySQLASTGen = /*#__PURE__*/function (_MySQLParserVisitor) {
     // | CREATE TEMPORARY? TABLE ifNotExists? tableName createDefinitions (tableOption (','? tableOption)*)? partitionDefinitions? # columnCreateTable
   }, {
     key: "visitCopyCreateTable",
-    value: function visitCopyCreateTable(ctx) {
+    value: function visitCopyCreateTable() {
       // not supported
     }
   }, {
@@ -629,7 +634,7 @@ var MySQLASTGen = /*#__PURE__*/function (_MySQLParserVisitor) {
     // uniqueKeyColumnConstraint: UNIQUE KEY?
   }, {
     key: "visitUniqueKeyColumnConstraint",
-    value: function visitUniqueKeyColumnConstraint(ctx) {
+    value: function visitUniqueKeyColumnConstraint() {
       return {
         kind: _constants.COLUMN_CONSTRAINT_KIND.UNIQUE,
         value: true
@@ -933,7 +938,7 @@ var MySQLASTGen = /*#__PURE__*/function (_MySQLParserVisitor) {
     }
   }, {
     key: "visitCheckTableConstraint",
-    value: function visitCheckTableConstraint(ctx) {
+    value: function visitCheckTableConstraint() {
       // ignored
     }
 
@@ -1142,6 +1147,154 @@ var MySQLASTGen = /*#__PURE__*/function (_MySQLParserVisitor) {
       });
       table.indexes.push(index);
     }
+
+    // dmlStatement
+    //   : selectStatement | insertStatement | updateStatement | deleteStatement | replaceStatement |
+    // callStatement | loadDataStatement | loadXmlStatement | doStatement | handlerStatement | valuesStatement | withStatement | tableStatement ;
+  }, {
+    key: "visitDmlStatement",
+    value: function visitDmlStatement(ctx) {
+      if (ctx.insertStatement()) {
+        ctx.insertStatement().accept(this);
+      }
+    }
+
+    // insertStatement
+    //   : INSERT priority = (LOW_PRIORITY | DELAYED | HIGH_PRIORITY)? IGNORE? INTO? tableName (
+    //       PARTITION '(' partitions = uidList? ')'
+    //   )? (
+    //       ('(' columns = fullColumnNameList? ')')? insertStatementValue (AS? uid)?
+    //       | SET setFirst = updatedElement (',' setElements += updatedElement)*
+    //   ) (
+    //       ON DUPLICATE KEY UPDATE duplicatedFirst = updatedElement (
+    //           ',' duplicatedElements += updatedElement
+    //       )*
+    //   )?
+    //   ;
+  }, {
+    key: "visitInsertStatement",
+    value: function visitInsertStatement(ctx) {
+      var names = ctx.tableName().accept(this);
+      var tableName = (0, _lodash.last)(names);
+      var schemaName = names.length > 1 ? names[names.length - 2] : undefined;
+
+      // insert without specified columns
+      var columns = ctx.fullColumnNameList() ? ctx.fullColumnNameList().accept(this) : [];
+      var values = ctx.insertStatementValue().accept(this);
+      var record = new _AST.TableRecord({
+        schemaName: schemaName,
+        tableName: tableName,
+        columns: columns,
+        values: values
+      });
+      this.data.records.push(record);
+    }
+
+    // fullColumnNameList
+    //   : fullColumnName (',' fullColumnName)*
+    //   ;
+  }, {
+    key: "visitFullColumnNameList",
+    value: function visitFullColumnNameList(ctx) {
+      var _this18 = this;
+      // [ [ 'id' ], [ 'name' ], [ 'email' ], [ 'created_at' ] ]
+      var columns = ctx.fullColumnName().map(function (fullColumn) {
+        return fullColumn.accept(_this18);
+      });
+      return (0, _lodash.flattenDepth)(columns, 1);
+    }
+
+    // insertStatementValue
+    //   : selectStatement
+    //   | insertFormat = (VALUES | VALUE) '(' expressionsWithDefaults? ')' (
+    //       ',' '(' expressionsWithDefaults? ')'
+    //   )*
+    //   ;
+  }, {
+    key: "visitInsertStatementValue",
+    value: function visitInsertStatementValue(ctx) {
+      var _this19 = this;
+      return ctx.expressionsWithDefaults().map(function (expression) {
+        // [
+        //   [ { value: '1', type: 'number' } ],
+        //   [ { value: 'Alice', type: 'string' } ],
+        //   [ { value: 'alice@host', type: 'string' } ],
+        //   [ { value: '2021-01-01', type: 'string' } ],
+        //   [ { value: '2021-01-01', type: 'string' } ],
+        // ]
+        var rowValues = expression.accept(_this19);
+        return (0, _lodash.flattenDepth)(rowValues, 1);
+      });
+    }
+
+    // expressionsWithDefaults
+    //   : expressionOrDefault (',' expressionOrDefault)*
+    //   ;
+  }, {
+    key: "visitExpressionsWithDefaults",
+    value: function visitExpressionsWithDefaults(ctx) {
+      var _this20 = this;
+      return ctx.expressionOrDefault().map(function (expressionOrDefault) {
+        var rawValues = expressionOrDefault.accept(_this20);
+
+        // We get the value of the column (constantExpressionAtom or functionCallExpressionAtom) through:
+        // expression->predicate->expressionAtom
+        var FLATTEN_DEPTH = 3;
+        var rawColumnValues = (0, _lodash.flattenDepth)(rawValues, FLATTEN_DEPTH);
+        // [ { value: '["555-1234", "555-5678"]', type: 'string' } ]
+        return rawColumnValues;
+      });
+    }
+
+    // predicate
+    //   : predicate NOT? IN '(' (selectStatement | expressions) ')'                            # inPredicate
+    //   | predicate IS nullNotnull                                                             # isNullPredicate
+    //   | left = predicate comparisonOperator right = predicate                                # binaryComparisonPredicate
+    //   | predicate comparisonOperator quantifier = (ALL | ANY | SOME) '(' selectStatement ')' # subqueryComparisonPredicate
+    //   | predicate NOT? BETWEEN predicate AND predicate                                       # betweenPredicate
+    //   | predicate SOUNDS LIKE predicate                                                      # soundsLikePredicate
+    //   | predicate NOT? LIKE predicate (ESCAPE STRING_LITERAL)?                               # likePredicate
+    //   | predicate NOT? regex = (REGEXP | RLIKE) predicate                                    # regexpPredicate
+    //   | predicate MEMBER OF '(' predicate ')'                                                # jsonMemberOfPredicate
+    //   | expressionAtom                                                                       # expressionAtomPredicate
+    //   ;
+
+    // expressionAtom
+    //   : constant                                                  # constantExpressionAtom
+    //   | fullColumnName                                            # fullColumnNameExpressionAtom
+    //   | functionCall                                              # functionCallExpressionAtom
+    //   | expressionAtom COLLATE collationName                      # collateExpressionAtom
+    //   | mysqlVariable                                             # mysqlVariableExpressionAtom
+    //   | unaryOperator expressionAtom                              # unaryExpressionAtom
+    //   | BINARY expressionAtom                                     # binaryExpressionAtom
+    //   | LOCAL_ID VAR_ASSIGN expressionAtom                        # variableAssignExpressionAtom
+    //   | '(' expression (',' expression)* ')'                      # nestedExpressionAtom
+    //   | ROW '(' expression (',' expression)+ ')'                  # nestedRowExpressionAtom
+    //   | EXISTS '(' selectStatement ')'                            # existsExpressionAtom
+    //   | '(' selectStatement ')'                                   # subqueryExpressionAtom
+    //   | INTERVAL expression intervalType                          # intervalExpressionAtom
+    //   | left = expressionAtom bitOperator right = expressionAtom  # bitExpressionAtom
+    //   | left = expressionAtom multOperator right = expressionAtom # mathExpressionAtom
+    //   | left = expressionAtom addOperator right = expressionAtom  # mathExpressionAtom
+    //   | left = expressionAtom jsonOperator right = expressionAtom # jsonExpressionAtom
+    //   ;
+
+    // functionCall
+    //   : specificFunction                         # specificFunctionCall
+    //   | aggregateWindowedFunction                # aggregateFunctionCall
+    //   | nonAggregateWindowedFunction             # nonAggregateFunctionCall
+    //   | scalarFunctionName '(' functionArgs? ')' # scalarFunctionCall
+    //   | fullId '(' functionArgs? ')'             # udfFunctionCall
+    //   | passwordFunctionClause                   # passwordFunctionCall
+    //   ;
+  }, {
+    key: "visitFunctionCallExpressionAtom",
+    value: function visitFunctionCallExpressionAtom(ctx) {
+      return {
+        value: ctx.getText(),
+        type: _constants.DATA_TYPE.EXPRESSION
+      };
+    }
   }]);
   return MySQLASTGen;
 }(_MySqlParserVisitor["default"]);

package/lib/parse/ANTLR/ASTGeneration/postgres/PostgresASTGen.js

@@ -69,7 +69,8 @@ var PostgresASTGen = /*#__PURE__*/function (_PostgreSQLParserVisi) {
       enums: [],
       tableGroups: [],
       aliases: [],
-      project: {}
+      project: {},
+      records: []
     };
     return _this;
   }
@@ -129,6 +130,10 @@ var PostgresASTGen = /*#__PURE__*/function (_PostgreSQLParserVisi) {
         ctx.definestmt().accept(this);
         return;
       }
+      if (ctx.insertstmt()) {
+        ctx.insertstmt().accept(this);
+        return;
+      }
     }
 
     /*
@@ -238,7 +243,7 @@ var PostgresASTGen = /*#__PURE__*/function (_PostgreSQLParserVisi) {
           })
           // value: {
           //   type: 'PrimaryKey',
-          //   columns: 
+          //   columns:
           // },
         };
       }
@@ -635,7 +640,7 @@ var PostgresASTGen = /*#__PURE__*/function (_PostgreSQLParserVisi) {
       });
     }
 
-    // DOT (attr_name | STAR) 
+    // DOT (attr_name | STAR)
     // | OPEN_BRACKET (a_expr | opt_slice_bound COLON opt_slice_bound) CLOSE_BRACKET
   }, {
     key: "visitIndirection_el",
@@ -830,7 +835,7 @@ var PostgresASTGen = /*#__PURE__*/function (_PostgreSQLParserVisi) {
       }
     }
 
-    // name | 
+    // name |
   }, {
     key: "visitOpt_index_name",
     value: function visitOpt_index_name(ctx) {
@@ -845,7 +850,7 @@ var PostgresASTGen = /*#__PURE__*/function (_PostgreSQLParserVisi) {
       return ctx.colid().accept(this);
     }
 
-    // USING name | 
+    // USING name |
   }, {
     key: "visitAccess_method_clause",
     value: function visitAccess_method_clause(ctx) {
@@ -1161,6 +1166,219 @@ var PostgresASTGen = /*#__PURE__*/function (_PostgreSQLParserVisi) {
         return s.accept(_this11);
       });
     }
+
+    // insertstmt
+    //  : opt_with_clause INSERT INTO insert_target insert_rest opt_on_conflict returning_clause
+    //  ;
+  }, {
+    key: "visitInsertstmt",
+    value: function visitInsertstmt(ctx) {
+      var names = ctx.insert_target().accept(this);
+      var tableName = (0, _lodash.last)(names);
+      var schemaName = names.length > 1 ? names[names.length - 2] : undefined;
+      var _ctx$insert_rest$acce = ctx.insert_rest().accept(this),
+        columns = _ctx$insert_rest$acce.columns,
+        values = _ctx$insert_rest$acce.values;
+      var record = new _AST.TableRecord({
+        schemaName: schemaName,
+        tableName: tableName,
+        columns: columns,
+        values: values
+      });
+      this.data.records.push(record);
+    }
+  }, {
+    key: "visitInsert_target",
+    value: function visitInsert_target(ctx) {
+      return ctx.qualified_name().accept(this);
+    }
+
+    // insert_rest
+    //  : selectstmt
+    //  | OVERRIDING override_kind VALUE_P selectstmt
+    //  | OPEN_PAREN insert_column_list CLOSE_PAREN (OVERRIDING override_kind VALUE_P)? selectstmt
+    //  | DEFAULT VALUES
+    //  ;
+  }, {
+    key: "visitInsert_rest",
+    value: function visitInsert_rest(ctx) {
+      var columns = ctx.insert_column_list() ? ctx.insert_column_list().accept(this) : [];
+      var rowsValue = ctx.selectstmt().accept(this) || [];
+      // each sub array represents a set of value of a row
+      // [
+      //   [
+      //     { value: '1', type: 'number' },
+      //     undefined,
+      //     {
+      //       value: '{"theme": "dark", "notifications": true}',
+      //       type: 'string',
+      //       type_name: 'JSONB',
+      //       schemaName: null
+      //     },
+      //     undefined,
+      //   ]
+      // ]
+
+      var sanitizeRowValue = function sanitizeRowValue(rowValue) {
+        return rowValue.filter(function (row) {
+          return row;
+        }).map(function (_ref) {
+          var value = _ref.value,
+            type = _ref.type;
+          return {
+            value: value,
+            type: type
+          };
+        });
+      };
+      var sanitizedRowsValue = rowsValue.filter(function (rowValue) {
+        return Array.isArray(rowValue);
+      }).map(sanitizeRowValue);
+      return {
+        columns: columns,
+        values: sanitizedRowsValue
+      };
+    }
+
+    // insert_column_list
+    //  : insert_column_item (COMMA insert_column_item)*
+    //  ;
+  }, {
+    key: "visitInsert_column_list",
+    value: function visitInsert_column_list(ctx) {
+      var _this12 = this;
+      return ctx.insert_column_item().map(function (colItem) {
+        return colItem.accept(_this12);
+      });
+    }
+
+    // insert_column_item
+    //  : colid opt_indirection
+    //  ;
+  }, {
+    key: "visitInsert_column_item",
+    value: function visitInsert_column_item(ctx) {
+      return ctx.colid().accept(this);
+    }
+
+    // selectstmt
+    //  : select_no_parens
+    //  | select_with_parens
+    //  ;
+  }, {
+    key: "visitSelectstmt",
+    value: function visitSelectstmt(ctx) {
+      if (!ctx.select_no_parens()) {
+        return null;
+      }
+      return ctx.select_no_parens().accept(this);
+    }
+
+    // select_no_parens
+    //  : select_clause opt_sort_clause (for_locking_clause opt_select_limit | select_limit opt_for_locking_clause)?
+    //  | with_clause select_clause opt_sort_clause (for_locking_clause opt_select_limit | select_limit opt_for_locking_clause)?
+    //  ;
+  }, {
+    key: "visitSelect_no_parens",
+    value: function visitSelect_no_parens(ctx) {
+      return ctx.select_clause().accept(this);
+    }
+
+    // select_clause
+    //  : simple_select
+    //  | select_with_parens
+    //  ;
+  }, {
+    key: "visitSelect_clause",
+    value: function visitSelect_clause(ctx) {
+      return ctx.simple_select().accept(this);
+    }
+
+    // simple_select
+    //  : ( SELECT (opt_all_clause into_clause opt_target_list | distinct_clause target_list)
+    //          into_clause
+    //          from_clause
+    //          where_clause
+    //          group_clause
+    //          having_clause
+    //          window_clause
+    //      | values_clause
+    //      | TABLE relation_expr
+    //      | select_with_parens set_operator_with_all_or_distinct (simple_select | select_with_parens)
+    //    )
+    //       (set_operator_with_all_or_distinct (simple_select | select_with_parens))*
+    //  ;
+  }, {
+    key: "visitSimple_select",
+    value: function visitSimple_select(ctx) {
+      if (!ctx.values_clause()) {
+        return null;
+      }
+      return ctx.values_clause().accept(this);
+    }
+
+    // values_clause
+    //  : VALUES OPEN_PAREN expr_list CLOSE_PAREN (COMMA OPEN_PAREN expr_list CLOSE_PAREN)*
+    //  ;
+  }, {
+    key: "visitValues_clause",
+    value: function visitValues_clause(ctx) {
+      var _this13 = this;
+      return ctx.expr_list().map(function (expr) {
+        var rawValues = expr.accept(_this13);
+
+        // We get the value of the c_expr through:
+        // a_expr->a_expr_qual->a_expr_lessless->a_expr_or->a_expr_and->
+        // a_expr_between->a_expr_in->a_expr_unary_not->a_expr_isnull->a_expr_is_not->
+        // a_expr_compare->a_expr_like->a_expr_qual_op->a_expr_unary_qualop->a_expr_add->
+        // a_expr_mul->a_expr_caret->a_expr_unary_sign->a_expr_at_time_zone->a_expr_collate->
+        // a_expr_typecast
+        var FLATTEN_DEPTH = 21;
+        var rawRowValues = (0, _lodash.flattenDepth)(rawValues, FLATTEN_DEPTH);
+
+        // [
+        //   { value: '1', type: 'number' },
+        //   undefined,
+        //   {
+        //     value: '{"theme": "dark", "notifications": true}',
+        //     type: 'string',
+        //     type_name: 'JSONB',
+        //     schemaName: null
+        //   },
+        //   undefined,
+        // ]
+        return rawRowValues;
+      });
+    }
+
+    // a_expr_collate
+    //  : a_expr_typecast (COLLATE any_name)?
+    //  ;
+  }, {
+    key: "visitA_expr_collate",
+    value: function visitA_expr_collate(ctx) {
+      var expressionValueSet = ctx.a_expr_typecast().accept(this);
+
+      // Possible values
+      // 1: [ { value: 'inactive', type: 'string' } ]
+      // 2: [
+      //   { value: '2021-01-05 18:45:00+00', type: 'string' },
+      //   undefined,
+      //   { type_name: 'TIMESTAMPTZ', schemaName: null }
+      // ]
+      // eslint-disable-next-line no-unused-vars
+      var _expressionValueSet = _slicedToArray(expressionValueSet, 3),
+        rawValue = _expressionValueSet[0],
+        _ = _expressionValueSet[1],
+        _expressionValueSet$ = _expressionValueSet[2],
+        rawType = _expressionValueSet$ === void 0 ? {} : _expressionValueSet$;
+      var value = rawValue.value,
+        type = rawValue.type;
+      return _objectSpread({
+        value: value,
+        type: type
+      }, rawType);
+    }
   }]);
   return PostgresASTGen;
 }(_PostgreSQLParserVisitor["default"]);

package/lib/parse/ANTLR/README.md

@@ -14,7 +14,12 @@
 - https://github.com/antlr/antlr4/blob/master/doc/javascript-target.md
 ## Setup a new parser
 1. Create a new folder inside the `packages/dbml-core/src/parse/ANTLR/parsers` folder (e.g. `postgresql`)
-2. Go to https://github.com/antlr/grammars-v4/tree/master/sql and clone the `<lang>Lexer.G4` and `<lang>Parser.G4` to the newly created folder.
+2. Get the grammar:
+
+- Go to https://github.com/antlr/grammars-v4/tree/master/sql and clone the `<lang>Lexer.G4` and `<lang>Parser.G4` to the newly created folder.
+
+- **Remember to add the original link to `<lang>Lexer.G4` and `<lang>Parser.G4`**
+
 3. Go to the folder:
     ```
     cd packages/dbml-core/src/parse/ANTLR/parsers/postgresql