docs: @Override
      protected AstNode parseAlterTableStatement( DdlTokenStream tokens,
                                                  AstNode parentNode ) throws ParsingException {
          assert tokens != null;
          assert parentNode != null;
  
          markStartOfStatement(tokens);
  
          // ALTER TABLE table-Name
          // {
          // ADD COLUMN column-definition |
          // ADD CONSTRAINT clause |
          // DROP [ COLUMN ] column-name [ CASCADE | RESTRICT ] |
          // DROP { PRIMARY KEY | FOREIGN KEY constraint-name | UNIQUE constraint-name | CHECK constraint-name | CONSTRAINT
          // constraint-name } |
          // ALTER [ COLUMN ] column-alteration |
          // LOCKSIZE { ROW | TABLE }
          // }
  
          tokens.consume(ALTER, TABLE); // consumes 'ALTER TABLE'
          String tableName = parseName(tokens);
  
          AstNode alterTableNode = nodeFactory().node(tableName, parentNode, TYPE_ALTER_TABLE_STATEMENT);
  
          // System.out.println("  >> PARSIN ALTER STATEMENT >>  TABLE Name = " + tableName);
  
          if (tokens.canConsume("ADD")) {
              if (isTableConstraint(tokens)) {
                  parseTableConstraint(tokens, alterTableNode, true);
              } else {
                  // This segment can also be enclosed in "()" brackets to handle multiple ColumnDefinition ADDs
                  if (tokens.matches(L_PAREN)) {
                      parseColumns(tokens, alterTableNode, true);
                  } else {
                      parseSingleTerminatedColumnDefinition(tokens, alterTableNode, true);
                  }
              }
  
          } else if (tokens.canConsume("DROP")) {
              // DROP { PRIMARY KEY | FOREIGN KEY constraint-name | UNIQUE constraint-name | CHECK constraint-name | CONSTRAINT
              // constraint-name }
              if (tokens.canConsume("PRIMARY", "KEY")) {
                  String name = parseName(tokens); // constraint name
                  nodeFactory().node(name, alterTableNode, TYPE_DROP_TABLE_CONSTRAINT_DEFINITION);
              } else if (tokens.canConsume("FOREIGN", "KEY")) {
                  String name = parseName(tokens); // constraint name
                  nodeFactory().node(name, alterTableNode, TYPE_DROP_TABLE_CONSTRAINT_DEFINITION);
              } else if (tokens.canConsume("UNIQUE")) {
                  String name = parseName(tokens); // constraint name
                  nodeFactory().node(name, alterTableNode, TYPE_DROP_TABLE_CONSTRAINT_DEFINITION);
              } else if (tokens.canConsume("CHECK")) {
                  String name = parseName(tokens); // constraint name
                  nodeFactory().node(name, alterTableNode, TYPE_DROP_TABLE_CONSTRAINT_DEFINITION);
              } else if (tokens.canConsume("CONSTRAINT")) {
                  String name = parseName(tokens); // constraint name
                  nodeFactory().node(name, alterTableNode, TYPE_DROP_TABLE_CONSTRAINT_DEFINITION);
              } else {
                  // DROP [ COLUMN ] column-name [ CASCADE | RESTRICT ]
                  tokens.canConsume("COLUMN"); // "COLUMN" is optional
  
                  String columnName = parseName(tokens);
  
                  AstNode columnNode = nodeFactory().node(columnName, alterTableNode, TYPE_DROP_COLUMN_DEFINITION);
  
                  if (tokens.canConsume(DropBehavior.CASCADE)) {
                      columnNode.setProperty(StandardDdlLexicon.DROP_BEHAVIOR, DropBehavior.CASCADE);
                  } else if (tokens.canConsume(DropBehavior.RESTRICT)) {
                      columnNode.setProperty(StandardDdlLexicon.DROP_BEHAVIOR, DropBehavior.RESTRICT);
                  }
              }
          } else if (tokens.canConsume("ALTER")) {
              // column-alteration
              //
              // ALTER [ COLUMN ] column-Name SET DATA TYPE VARCHAR(integer) |
              // ALTER [ COLUMN ] column-Name SET DATA TYPE VARCHAR FOR BIT DATA(integer) |
              // ALTER [ COLUMN ] column-name SET INCREMENT BY integer-constant |
              // ALTER [ COLUMN ] column-name RESTART WITH integer-constant |
              // ALTER [ COLUMN ] column-name [ NOT ] NULL |
              // ALTER [ COLUMN ] column-name [ WITH | SET ] DEFAULT default-value |
              // ALTER [ COLUMN ] column-name DROP DEFAULT
  
              tokens.canConsume("COLUMN");
              String alterColumnName = parseName(tokens);
  
              AstNode columnNode = nodeFactory().node(alterColumnName, alterTableNode, TYPE_ALTER_COLUMN_DEFINITION);
  
              if (tokens.matches("DEFAULT")) {
                  parseDefaultClause(tokens, columnNode);
              } else if (tokens.canConsume("SET")) {
                  if (tokens.canConsume("DATA", "TYPE")) {
                      DataType datatype = getDatatypeParser().parse(tokens);
  
                      columnNode.setProperty(StandardDdlLexicon.DATATYPE_NAME, datatype.getName());
                      if (datatype.getLength() >= 0) {
                          columnNode.setProperty(StandardDdlLexicon.DATATYPE_LENGTH, datatype.getLength());
                      }
                      if (datatype.getPrecision() >= 0) {
                          columnNode.setProperty(StandardDdlLexicon.DATATYPE_PRECISION, datatype.getPrecision());
                      }
                      if (datatype.getScale() >= 0) {
                          columnNode.setProperty(StandardDdlLexicon.DATATYPE_SCALE, datatype.getScale());
                      }
  
                  } else if (tokens.canConsume("INCREMENT")) {
                      tokens.consume("BY", TokenStream.ANY_VALUE);
                  }
                  if (tokens.matches("DEFAULT")) {
                      parseDefaultClause(tokens, columnNode);
                  }
              } else if (tokens.canConsume("WITH")) {
                  parseDefaultClause(tokens, columnNode);
              } else {
                  tokens.canConsume("RESTART", "WITH", TokenStream.ANY_VALUE);
                  tokens.canConsume("DROP", "DEFAULT");
  
                  if (tokens.canConsume("NOT", "NULL")) {
                      columnNode.setProperty(StandardDdlLexicon.NULLABLE, "NOT NULL");
                  } else if (tokens.canConsume("NULL")) {
                      columnNode.setProperty(StandardDdlLexicon.NULLABLE, "NULL");
                  }
              }
  
          } else if (tokens.canConsume("LOCKSIZE")) {
              tokens.canConsume("ROWS");
              tokens.canConsume("TABLE");
          }
  
          markEndOfStatement(tokens, alterTableNode);
  
          return alterTableNode;
      }