Bug #81815 GRT serializing: string too long while reopening a file
Submitted: 11 Jun 2016 19:05 Modified: 14 Jul 2016 12:37
Reporter: M L Email Updates:
Status: No Feedback Impact on me:
None 
Category:MySQL Workbench: Modeling Severity:S1 (Critical)
Version:6.3.6 OS:Microsoft Windows (Microsoft Windows 10 Home)
Assigned to: CPU Architecture:Any
Tags: GRTstringTooLong, WBBugReporter

[11 Jun 2016 19:05] M L
Description:
Saving a model works well, but after closing trying to reopen, the following error is written into the log file:

[      WBContext]: Error unserializing GRT data
string too long
20:56:19 [ERR][      WBContext]: Error unserializing GRT data
string too long

Is there a chance that this will be fixed soon? The modeler offers a great user experience, but if a model won't reopen, thats a pity :/

How to repeat:
New Model
Import -> Reverse Engineer from SQL
Moving stuff around
Saving (works great so far)
Closing
Try to reopen --> string too long Error comes up

the model contains some long table names, might that cause the error?

the model was created out of the following file:
/*
	------------------------------------------------------------------------------
	Ticketingsystem
	Kemptner Stefan, Lackner Mathias
	------------------------------------------------------------------------------
*/

/*
	------------------------------------------------------------------------------
	CREATING TABLES
	------------------------------------------------------------------------------
    Primary Key Symbole:
    adressen:		adress_id_pk
    stadion:		stadion_id_pk
    kunden:			kunden_id_pk
    sektor:			sektor_id_pk
    sitzplaetze:	platz_sektor_pk
    typen:			typ_id_pk
    status:			status_id
    team:			team_id_pk
    wiederholungen:	wdh_id_pk
    serie:			serien_id_pk
    spiele:			spiel_id_pk
    tickets:		ticket_id_pk
    reservierungen:	reservierungs_id_pk
    
    
    Foreign Key Symbole:
    stadion:		stadion_adress_id_fk
    kunden:			kunden_adress_id_fk
    sektor:			sektor_stadion_id_fk
    sitzplaetze:	platz_sektor_id_fk
    serie:			serien_wdh_id_fk
    spiele:			spiel_stadion_id_fk
					spiel_serien_id_fk
					spiel_team_id_A_fk
                    spiel_team_id_B_fk
	tickets:		ticket_spiel_id_fk
                    ticket_platz_sektor_fk
                    status_id_fk
	reservierungen:	reservierungs_kunden_id_fk
					reservierungs_ticket_id_fk
                    reservierungs_typ_id_fk
*/

CREATE TABLE adressen
(
  adress_id			INTEGER NOT NULL,
  strasse			VARCHAR (30) NOT NULL,
  hausnummer		INTEGER NOT NULL,
  ort				VARCHAR (30) NOT NULL,
  plz				INTEGER NOT NULL,
  CONSTRAINT adress_id_pk PRIMARY KEY (adress_id)
);

CREATE TABLE stadion
(
  stadion_id		INTEGER NOT NULL,
  stadion_name		VARCHAR (30) NOT NULL,
  adress_id			INTEGER NOT NULL,
  CONSTRAINT stadion_id_pk PRIMARY KEY (stadion_id),
  CONSTRAINT stadion_adress_id_fk FOREIGN KEY (adress_id)
    REFERENCES adressen (adress_id)
);

CREATE TABLE kunden
(
  kunden_id			INTEGER NOT NULL,
  vorname			VARCHAR (30) NOT NULL,
  nachname			VARCHAR (30) NOT NULL,
  adress_id			INTEGER,
  CONSTRAINT kunden_id_pk PRIMARY KEY (kunden_id),
  CONSTRAINT kunden_adress_id_fk FOREIGN KEY (adress_id)
    REFERENCES adressen (adress_id)
);

CREATE TABLE sektor
(
  sektor_id			INTEGER NOT NULL,
  -- sektoren in verschiedenen Stadien müssen unterschiedliche sektor_ids aufweisen!
  sektor_name		VARCHAR (30),
  stadion_id		INTEGER NOT NULL,
  CONSTRAINT sektor_id_pk PRIMARY KEY  (sektor_id),
  CONSTRAINT sektor_stadion_id_fk FOREIGN KEY (stadion_id)
    REFERENCES stadion (stadion_id)
      ON DELETE CASCADE
      -- wird das Stadion gelöscht, werden auch alle zugehörigen Sektoren gelöscht.
);

CREATE TABLE sitzplaetze
(
  platz_nr			INTEGER NOT NULL,
  sektor_id			INTEGER NOT NULL,
  CONSTRAINT platz_sektor_pk PRIMARY KEY (platz_nr, sektor_id),
  CONSTRAINT platz_sektor_id_fk FOREIGN KEY (sektor_id)
    REFERENCES sektor(sektor_id)
      ON DELETE CASCADE
      -- wird der Sektor gelöscht, werden auch alle zugehörigen Sitzplätze gelöscht.
);

CREATE TABLE typen
(
  typ_id			INTEGER NOT NULL,
  typ_name			VARCHAR (30) NOT NULL,
  CONSTRAINT typ_id_pk PRIMARY KEY (typ_id)
);

CREATE TABLE status
(
  status_id			INTEGER NOT NULL ,
  status_name		VARCHAR (30) NOT NULL ,
  CONSTRAINT status_id_pk PRIMARY KEY (status_id)
);

CREATE TABLE team
(
  team_id			INTEGER NOT NULL,
  team_name			VARCHAR (30) NOT NULL,
  CONSTRAINT team_id_pk PRIMARY KEY (team_id)
);

CREATE TABLE wiederholungen
(
  wdh_id			INTEGER NOT NULL,
  intervall			INTEGER NOT NULL,
  CONSTRAINT wdh_id_pk PRIMARY KEY (wdh_id)
);

CREATE TABLE serie
(
  serien_id			INTEGER NOT NULL ,
  serien_name		VARCHAR (30) NOT NULL ,
  wdh_id			INTEGER,
  CONSTRAINT serien_id_pk PRIMARY KEY (serien_id),
  CONSTRAINT serien_wdh_id_fk FOREIGN KEY (wdh_id)
    REFERENCES wiederholungen (wdh_id)
);

CREATE TABLE spiele
(
  spiel_id			INTEGER NOT NULL ,
  stadion_id		INTEGER ,
  serien_id			INTEGER,
  team_id_A			INTEGER,
  team_id_B			INTEGER,
  -- Stadion und Serie müssen nicht gesetzt sein (NULL steht für noch nicht entschiedene Zuordnung)
  -- TODO eventuell abändern auf Stadion_id und Serien_id  = 'unbekannt'? Wenn dann auch ON DELETE RESTRICT
  -- Wegen tickets, da diese eine sektor_id brauchen
  CONSTRAINT spiel_id_pk PRIMARY KEY (spiel_id),
  CONSTRAINT spiel_stadion_id_fk FOREIGN KEY (stadion_id)
    REFERENCES stadion (stadion_id)
      ON DELETE SET NULL,
      -- das Stadion darf gelöscht werden, das Spiel erhält dann das Stadion NULL
  CONSTRAINT spiel_serien_id_fk FOREIGN KEY (serien_id)
    REFERENCES serie (serien_id)
      ON DELETE SET NULL,
      -- die Serie darf gelöscht werden, das Spiel erhält dann die Serie NULL
  CONSTRAINT spiel_team_id_A_fk FOREIGN KEY (team_id_A)
    REFERENCES team (team_id)
      ON DELETE CASCADE,
      -- wird ein Team gelöscht, wird auch das Spiel gelöscht
  CONSTRAINT spiel_team_id_B_fk FOREIGN KEY (team_id_B)
    REFERENCES team (team_id)
      ON DELETE CASCADE
      -- wird ein Team gelöscht, wird auch das Spiel gelöscht
);

CREATE TABLE tickets
(
  ticket_id			INTEGER NOT NULL,
  spiel_id			INTEGER NOT NULL,
  sektor_id			INTEGER NOT NULL,
  platz_nr			INTEGER NOT NULL,
  status_id			INTEGER NOT NULL,
  CONSTRAINT ticket_id_pk PRIMARY KEY (ticket_id),
  CONSTRAINT ticket_spiel_id_fk FOREIGN KEY (spiel_id)
    REFERENCES spiele(spiel_id)
      ON DELETE CASCADE,
      -- wird das Spiel gelöscht wird auch das Ticket gelöscht, TODO: Überlegen ob Absicht?
  CONSTRAINT ticket_platz_sektor_fk FOREIGN KEY (platz_nr,sektor_id)
    REFERENCES SITZPLAETZE(platz_nr,sektor_id)
      ON DELETE CASCADE,
      -- wird der Sitzplatz gelöscht, wird auch das Ticket gelöscht, TODO: Überlegen ob Absicht?
  CONSTRAINT status_id_fk FOREIGN KEY (status_id)
    REFERENCES status (status_id)
      ON DELETE RESTRICT
      -- Löschen eines Status ist nicht erlaubt solange dieser noch vergeben ist.
);

CREATE TABLE reservierungen
(
  reservierungs_id	INTEGER NOT NULL,
  kunden_id			INTEGER NOT NULL,
  ticket_id			INTEGER NOT NULL,
  typ_id			INTEGER NOT NULL,
  CONSTRAINT reservierungs_id_pk PRIMARY KEY (reservierungs_id),
  CONSTRAINT reservierungs_kunden_id_fk FOREIGN KEY (kunden_id)
    REFERENCES kunden (kunden_id)
      ON DELETE CASCADE,
      -- wird der Kunde gelöscht, wird auch die Reservierung gelöscht
  CONSTRAINT reservierungs_ticket_id_fk FOREIGN KEY (ticket_id)
    REFERENCES TICKETS (ticket_id)
      ON DELETE CASCADE,
      -- wird der Kunde gelöscht, wird auch das Ticket gelöscht
  CONSTRAINT reservierungs_typ_id_fk FOREIGN KEY (typ_id)
    REFERENCES typen (typ_id)
      ON DELETE CASCADE
      -- wird der Reservierungstyp gelöscht, wird auch das Ticket gelöscht, TODO: Überlegen ob Absicht? Besser: ON DELETE RESTRICT?
);

CREATE TABLE preise
(
  serien_id			INTEGER NOT NULL,
  sektor_id			INTEGER NOT NULL,
  preis				INTEGER NOT NULL,
  CONSTRAINT serien_sektor_pk PRIMARY KEY (serien_id,sektor_id),
  CONSTRAINT serien_id_fk FOREIGN KEY (serien_id)
    REFERENCES serie (serien_id)
      ON DELETE CASCADE,
      -- wird eine Serie gelöscht, wird auch der davon abhängige Preis gelöscht
  CONSTRAINT sektor_id_fk FOREIGN KEY (sektor_id)
    REFERENCES sektor (sektor_id)
      ON DELETE CASCADE
      -- wird ein Sektor gelöscht, wird auch der davon abhängige Preis gelöscht
);

/*
	------------------------------------------------------------------------------
	CREATING VIEWS
	------------------------------------------------------------------------------
*/
CREATE VIEW volltext_ticket AS SELECT
  st.stadion_name,
  adr1.strasse, adr1.hausnummer, adr1.ort, adr1.plz,
  t1.team_name AS team_a, t2.team_name AS team_b,
  sek.sektor_id, sek.sektor_name,
  ser.serien_name,
  p.preis,
  si.platz_nr,
  typen.typ_name,
  ku.vorname, ku.nachname
FROM stadion st	JOIN adressen adr1		ON (st.adress_id = adr1.adress_id)
				JOIN spiele sp			ON (sp.stadion_id = st.stadion_id)
                JOIN team t1			ON (sp.team_id_A = t1.team_id)
                JOIN team t2			ON (sp.team_id_B = t2.team_id)
                JOIN serie ser			ON (ser.serien_id = sp.serien_id)
                JOIN preise p			ON (p.serien_id = p.serien_id)
                JOIN sektor sek			ON (sek.sektor_id = p.sektor_id)
                JOIN sitzplaetze si		ON (si.sektor_id = sek.sektor_id)
                JOIN tickets ti			ON (ti.platz_nr = si.platz_nr)
                JOIN reservierungen res ON (res.ticket_id = ti.ticket_id)
                JOIN typen				ON (typen.typ_id = res.typ_id)
                JOIN kunden ku			ON (ku.kunden_id = res.kunden_id);
[14 Jun 2016 12:37] Miguel Solorzano
Please try version 6.3.7. Thanks.
[15 Jul 2016 1:00] Bugs System
No feedback was provided for this bug for over a month, so it is
being suspended automatically. If you are able to provide the
information that was originally requested, please do so and change
the status of the bug back to "Open".