Exemple #1
0
    def testForeignKey01SpecialCase(self):
        clauses = """
		LOREM: -ipsum, dolor, sit
		CONSECTETUER: elit, sed
		SUSPENDISSE: diam
		SOLLICITUDIN, 01 SUSPENDISSE, 0N /CONSECTETUER, 0N /LOREM: lectus
		"""
        t = Tables(Mcd(clauses.split("\n"), {"df": u"DF", "sep": u","}))
        t.processAll()
        expected = {
            'name':
            'SOLLICITUDIN',
            'index':
            3,
            'columns': [
                {
                    'format': 'nonDf',
                    'attribute': 'diam',
                    'attributeType': None,
                    'association': 'SOLLICITUDIN',
                    'entity': 'SUSPENDISSE',
                    'primary': True,
                    'foreign': True
                },
                {
                    'format': 'nonDf',
                    'attribute': 'elit',
                    'attributeType': None,
                    'association': 'SOLLICITUDIN',
                    'entity': 'CONSECTETUER',
                    'primary': False,
                    'foreign': True
                },
                {
                    'format': 'nonDf',
                    'attribute': 'ipsum',
                    'attributeType': None,
                    'association': 'SOLLICITUDIN',
                    'entity': 'LOREM',
                    'primary': False,
                    'foreign': True
                },
                {
                    'attribute': 'lectus',
                    'attributeType': None,
                    'primary': False,
                    'foreign': False
                },
            ],
        }
        self.assert_('SOLLICITUDIN' in t.tables)
        self.assertEqual(t.tables['SOLLICITUDIN'], expected)
Exemple #2
0
    def testOrderWithNameClashes(self):
        clauses = """
		LOREM1: -ipsum, dolor, sit
		LOREM2: elit, sed
		LOREM3: diam
		LOREM4, 11 LOREM1, 1N LOREM2: transit
		LOREM4, 0N LOREM3, 0N LOREM2, 0N LOREM1: lectus
		"""
        t = Tables(Mcd(clauses.split("\n"), {"df": u"DF", "sep": u","}))
        t.processAll()
        expected = [(0, 'ipsum, dolor, sit'), (1, 'elit, sed'), (2, 'diam'),
                    (4, 'diam, elit, ipsum, lectus')]
        self.assertEqual(
            expected,
            sorted((d["index"],
                    ", ".join([column["attribute"]
                               for column in d["columns"]]))
                   for d in t.tables.values()))
Exemple #3
0
    clauses = u"""
        SUSPENDISSE: diam
        SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus
        CONSECTETUER: elit, sed
        MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM

        DF1, 11 LOREM, 1N SUSPENDISSE
        LOREM: ipsum, dolor, sit
        TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec
        DIGNISSIM: ligula, massa, varius

        DF, 11 RISUS, 0N RISUS
        AMET, 11> LOREM, 01 CONSECTETUER: adipiscing
        RISUS: ultricies, _cras, elementum
        SEMPER, 0N RISUS, 1N DIGNISSIM
    """.replace("  ", "").split("\n")
    params = parsed_arguments()
    params["verbose"] = True
    mcd = Mcd(clauses, params)
    params.update(mcd.get_layout_data())
    starting_time = time()
    seed(42)
    result = arrange(**params)
    if result:
        print
        print mcd.get_clauses_from_layout(**result)
        print
        print "Cumulated distances:", result["distances"]
        print "Duration:", time() - starting_time
        print 
Exemple #4
0
def main():
    try:
        params = parsed_arguments()
        common = Common(params)
        clauses = common.load_input_file()
        if params["restore"]:
            import shutil

            shutil.copyfile(os.path.join(params["script_directory"], "pristine_sandbox.mcd"), "sandbox.mcd")
            return open("params.json", "w").write("{}")
        if params["print_params"]:
            import json

            for added_key in params["added_keys"][:]:
                del params[added_key]
            params["print_params"] = False
            params_contents = json.dumps(params, ensure_ascii=False, indent=2, sort_keys=True)
            return safe_print_for_PHP(params_contents)
        if params["obfuscate"]:
            from obfuscate import obfuscate

            return safe_print_for_PHP(obfuscate(clauses, params))
        mcd = Mcd(clauses, params)
        if params["flip"]:
            return safe_print_for_PHP(
                {
                    "v": mcd.get_clauses_vertical_mirror,
                    "h": mcd.get_clauses_horizontal_mirror,
                    "d": mcd.get_clauses_diagonal_mirror,
                }[params["flip"]]()
            )
        if params["arrange"]:
            params.update(mcd.get_layout_data())
            if params["arrange"] == "ga":
                from arrange_ga import arrange
            elif params["arrange"] == "bb":
                from arrange_bb import arrange
            result = arrange(**params)
            if result:
                return safe_print_for_PHP(mcd.get_clauses_from_layout(**result))
            raise RuntimeError(("Mocodo Err.9 - " + _("Failed to calculate a planar layout.")).encode("utf8"))
        relations = Relations(mcd, params)
        common.dump_mld_files(relations)
        if params["image_format"] == "svg":
            from mcd_to_svg import main
            import runpy

            main(mcd, common)
            runpy.run_path(u"%(output_name)s_svg.py" % params)
            return
        if params["image_format"] == "nodebox":
            from mcd_to_nodebox import main

            main(mcd, common)
            return os.system(u"""open -a NodeBox "%(output_name)s_nodebox.py" """ % params)
        raise RuntimeError(("Mocodo Err.13 - " + _("Should never happen.")).encode("utf8"))
    except RuntimeError, err:
        msg = str(err)
        if msg.startswith("Mocodo Err."):
            print >> sys.stderr, msg
        else:
            raise
Exemple #5
0
    def testMySQLOutput(self):
        format = {
            "extension":
            ".sql",
            "opening":
            "",
            "table":
            "`%s`",
            "primary":
            "`%s`",
            "simple":
            "`%s`",
            "foreign":
            "`%s`",
            "foreignPrimary":
            "`%s`",
            "attributeWithType":
            "%(attribute)s %(attributeType)s",
            "columnSep":
            ",\n  ",
            "line":
            "CREATE TABLE %(table)s (\n  %(columns)s,\n  PRIMARY KEY(%(primaryList)s)\n) ENGINE=InnoDB  DEFAULT CHARSET=utf8;",
            "lineSep":
            "\n\n",
            "primarySep":
            ", ",
            "closing":
            "",
            "comment":
            "/*\n%s\n*/",
            "strengthen":
            "%(attribute)s",
            "df":
            "%(attribute)s",
            "nonDf":
            "%(attribute)s",
            "distinguish":
            "%(label)s.%(count)s",
            "replace": [],
            "addForeignKey":
            "ALTER TABLE `%(table)s` ADD FOREIGN KEY (`%(foreignKey)s`) REFERENCES `%(foreignTable)s` (`%(foreignKey)s`) ON UPDATE CASCADE;"
        }
        clauses = """
		CLIENT: Réf. client [varchar(8)], Nom [varchar(20)], Prénom [varchar(20)], Adresse [varchar(40)]
		DF, 0N CLIENT, 11 COMMANDE
		COMMANDE: Num commande [tinyint(4)], Date [date], Montant [decimal(5,2) DEFAULT '0.00']
		INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité [tinyint(4)]
		PRODUIT: Réf. produit [varchar(8)], Libellé [varchar(20)], Prix unitaire [decimal(5,2) DEFAULT '0.00']
		"""
        t = Tables(Mcd(clauses.split("\n"), {"df": u"DF", "sep": u","}))
        t.processAll()
        expected = """\
CREATE TABLE `CLIENT` (
  `Réf. client` varchar(8),
  `Nom` varchar(20),
  `Prénom` varchar(20),
  `Adresse` varchar(40),
  PRIMARY KEY(`Réf. client`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

CREATE TABLE `COMMANDE` (
  `Num commande` tinyint(4),
  `Date` date,
  `Montant` decimal(5,2) DEFAULT '0.00',
  `Réf. client` varchar(8),
  PRIMARY KEY(`Num commande`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

CREATE TABLE `INCLURE` (
  `Num commande` tinyint(4),
  `Réf. produit` varchar(8),
  `Quantité` tinyint(4),
  PRIMARY KEY(`Num commande`, `Réf. produit`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

CREATE TABLE `PRODUIT` (
  `Réf. produit` varchar(8),
  `Libellé` varchar(20),
  `Prix unitaire` decimal(5,2) DEFAULT '0.00',
  PRIMARY KEY(`Réf. produit`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

ALTER TABLE `COMMANDE` ADD FOREIGN KEY (`Réf. client`) REFERENCES `CLIENT` (`Réf. client`) ON UPDATE CASCADE;

ALTER TABLE `INCLURE` ADD FOREIGN KEY (`Num commande`) REFERENCES `COMMANDE` (`Num commande`) ON UPDATE CASCADE;

ALTER TABLE `INCLURE` ADD FOREIGN KEY (`Réf. produit`) REFERENCES `PRODUIT` (`Réf. produit`) ON UPDATE CASCADE;"""
        self.assertEqual(t.getText(format), expected)
        #
        # The same, with automatic comment when one foreign table has only one attribute
        #
        clauses = """
		CLIENT: Réf. client [varchar(8)]
		DF, 0N CLIENT, 11 COMMANDE
		COMMANDE: Num commande [tinyint(4)], Date [date], Montant [decimal(5,2) DEFAULT '0.00']
		INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité [tinyint(4)]
		PRODUIT: Réf. produit [varchar(8)], Libellé [varchar(20)], Prix unitaire [decimal(5,2) DEFAULT '0.00']
		"""
        t = Tables(Mcd(clauses.split("\n"), {"df": u"DF", "sep": u","}))
        t.processAll()
        expected = """\
/*
CREATE TABLE `CLIENT` (
  `Réf. client` varchar(8),
  PRIMARY KEY(`Réf. client`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
*/

CREATE TABLE `COMMANDE` (
  `Num commande` tinyint(4),
  `Date` date,
  `Montant` decimal(5,2) DEFAULT '0.00',
  `Réf. client` varchar(8),
  PRIMARY KEY(`Num commande`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

CREATE TABLE `INCLURE` (
  `Num commande` tinyint(4),
  `Réf. produit` varchar(8),
  `Quantité` tinyint(4),
  PRIMARY KEY(`Num commande`, `Réf. produit`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

CREATE TABLE `PRODUIT` (
  `Réf. produit` varchar(8),
  `Libellé` varchar(20),
  `Prix unitaire` decimal(5,2) DEFAULT '0.00',
  PRIMARY KEY(`Réf. produit`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

/*
ALTER TABLE `COMMANDE` ADD FOREIGN KEY (`Réf. client`) REFERENCES `CLIENT` (`Réf. client`) ON UPDATE CASCADE;
*/

ALTER TABLE `INCLURE` ADD FOREIGN KEY (`Num commande`) REFERENCES `COMMANDE` (`Num commande`) ON UPDATE CASCADE;

ALTER TABLE `INCLURE` ADD FOREIGN KEY (`Réf. produit`) REFERENCES `PRODUIT` (`Réf. produit`) ON UPDATE CASCADE;"""
        self.assertEqual(t.getText(format), expected)
Exemple #6
0
    def testGeneralCase(self):
        clauses = """
		LOREM: -ipsum, dolor, sit
		AMET, 11 LOREM, 01 CONSECTETUER: adipiscing
		CONSECTETUER: elit, sed
		NON, 11 RISUS, 0N RISUS

		DF, 11 LOREM, 1N SUSPENDISSE
		SOLLICITUDIN, 0N SUSPENDISSE, 0N CONSECTETUER, 0N LOREM: lectus
		TORTOR, 0N RISUS, 11 DIGNISSIM, 1N CONSECTETUER: nec
		RISUS: ultricies, _cras, elementum

		SUSPENDISSE: diam
		MAECENAS, 1N DIGNISSIM, 1N DIGNISSIM
		DIGNISSIM: ligula, massa, varius
		SEMPER, 0N RISUS, 1N DIGNISSIM
		"""
        t = Tables(Mcd(clauses.split("\n"), {"df": u"DF", "sep": u","}))
        expected = {
            'CONSECTETUER': {
                'name':
                'CONSECTETUER',
                'columns': [
                    {
                        'attribute': 'elit',
                        'attributeType': None,
                        'primary': True,
                        'foreign': False
                    },
                    {
                        'attribute': 'sed',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                ],
            },
            'DIGNISSIM': {
                'name':
                'DIGNISSIM',
                'columns': [
                    {
                        'attribute': 'ligula',
                        'attributeType': None,
                        'primary': True,
                        'foreign': False
                    },
                    {
                        'attribute': 'massa',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                    {
                        'attribute': 'varius',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                ],
            },
            'LOREM': {
                'name':
                'LOREM',
                'columns': [
                    {
                        'attribute': 'ipsum',
                        'attributeType': None,
                        'primary': True,
                        'foreign': False
                    },
                    {
                        'attribute': 'dolor',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                    {
                        'attribute': 'sit',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                ],
            },
            'RISUS': {
                'name':
                'RISUS',
                'columns': [
                    {
                        'attribute': 'ultricies',
                        'attributeType': None,
                        'primary': True,
                        'foreign': False
                    },
                    {
                        'attribute': 'cras',
                        'attributeType': None,
                        'primary': True,
                        'foreign': False
                    },
                    {
                        'attribute': 'elementum',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                ],
            },
            'SUSPENDISSE': {
                'name':
                'SUSPENDISSE',
                'columns': [
                    {
                        'attribute': 'diam',
                        'attributeType': None,
                        'primary': True,
                        'foreign': False
                    },
                ],
            }
        }
        t.tablesFromEntities()
        self.assertEqual(t.tables, expected)
        expected.update({
            'LOREM': {
                'name':
                'LOREM',
                'columns': [
                    {
                        'format': 'strengthen',
                        'attribute': 'diam',
                        'attributeType': None,
                        'association': 'DF',
                        'entity': 'SUSPENDISSE',
                        'primary': True,
                        'foreign': True
                    },
                    {
                        'attribute': 'ipsum',
                        'attributeType': None,
                        'primary': True,
                        'foreign': False
                    },
                    {
                        'attribute': 'dolor',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                    {
                        'attribute': 'sit',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                ],
            }
        })
        t.strengthenWeakIdentifiers()
        self.assertEqual(t.tables, expected)
        expected.update({
            'SEMPER': {
                'name':
                'SEMPER',
                'columns': [
                    {
                        'format': 'nonDf',
                        'attribute': 'ultricies',
                        'attributeType': None,
                        'association': 'SEMPER',
                        'entity': 'RISUS',
                        'primary': True,
                        'foreign': True
                    },
                    {
                        'format': 'nonDf',
                        'attribute': 'cras',
                        'attributeType': None,
                        'association': 'SEMPER',
                        'entity': 'RISUS',
                        'primary': True,
                        'foreign': True
                    },
                    {
                        'format': 'nonDf',
                        'attribute': 'ligula',
                        'attributeType': None,
                        'association': 'SEMPER',
                        'entity': 'DIGNISSIM',
                        'primary': True,
                        'foreign': True
                    },
                ],
            },
            'SOLLICITUDIN': {
                'name':
                'SOLLICITUDIN',
                'columns': [
                    {
                        'format': 'nonDf',
                        'attribute': 'diam',
                        'attributeType': None,
                        'association': 'SOLLICITUDIN',
                        'entity': 'SUSPENDISSE',
                        'primary': True,
                        'foreign': True
                    },
                    {
                        'format': 'nonDf',
                        'attribute': 'elit',
                        'attributeType': None,
                        'association': 'SOLLICITUDIN',
                        'entity': 'CONSECTETUER',
                        'primary': True,
                        'foreign': True
                    },
                    {
                        'format': 'nonDf',
                        'attribute': 'diam',
                        'attributeType': None,
                        'association': 'SOLLICITUDIN',
                        'entity': 'LOREM',
                        'primary': True,
                        'foreign': True
                    },
                    {
                        'format': 'nonDf',
                        'attribute': 'ipsum',
                        'attributeType': None,
                        'association': 'SOLLICITUDIN',
                        'entity': 'LOREM',
                        'primary': True,
                        'foreign': True
                    },
                    {
                        'attribute': 'lectus',
                        'attributeType': None,
                        'primary': False,
                        'foreign': False
                    },
                ],
            },
            'MAECENAS': {
                'name':
                'MAECENAS',
                'columns': [
                    {
                        'format': 'nonDf',
                        'attribute': 'ligula',
                        'attributeType': None,
                        'association': 'MAECENAS',
                        'entity': 'DIGNISSIM',
                        'primary': True,
                        'foreign': True
                    },
                    {
                        'format': 'nonDf',
                        'attribute': 'ligula',
                        'attributeType': None,
                        'association': 'MAECENAS',
                        'entity': 'DIGNISSIM',
                        'primary': True,
                        'foreign': True
                    },
                ],
            },
        })
        expected["RISUS"]["columns"].extend([
            {
                'format': 'df',
                'attribute': 'ultricies',
                'attributeType': None,
                'association': 'NON',
                'entity': 'RISUS',
                'primary': False,
                'foreign': True
            },
            {
                'format': 'df',
                'attribute': 'cras',
                'attributeType': None,
                'association': 'NON',
                'entity': 'RISUS',
                'primary': False,
                'foreign': True
            },
        ])
        expected["DIGNISSIM"]["columns"].extend([
            {
                'format': 'df',
                'attribute': 'ultricies',
                'attributeType': None,
                'association': 'TORTOR',
                'entity': 'RISUS',
                'primary': False,
                'foreign': True
            },
            {
                'format': 'df',
                'attribute': 'cras',
                'attributeType': None,
                'association': 'TORTOR',
                'entity': 'RISUS',
                'primary': False,
                'foreign': True
            },
            {
                'format': 'df',
                'attribute': 'elit',
                'attributeType': None,
                'association': 'TORTOR',
                'entity': 'CONSECTETUER',
                'primary': False,
                'foreign': True
            },
            {
                'attribute': 'nec',
                'attributeType': None,
                'primary': False,
                'foreign': False
            },
        ])
        expected["LOREM"]["columns"].extend([
            {
                'format': 'df',
                'attribute': 'elit',
                'attributeType': None,
                'association': 'AMET',
                'entity': 'CONSECTETUER',
                'primary': False,
                'foreign': True
            },
            {
                'attribute': 'adipiscing',
                'attributeType': None,
                'primary': False,
                'foreign': False
            },
        ])
        t.processAssociations()
        self.assertEqual(t.tables, expected)
        format = {
            "extension": ".txt",
            "opening": "",
            "table": "%s",
            "primary": "_%s_",
            "simple": "%s",
            "foreign": "#%s",
            "foreignPrimary": "_#%s_",
            "columnSep": ", ",
            "line": "%(table)s (%(columns)s)",
            "lineSep": "\n",
            "closing": "",
            "comment": "--- %s",
            "replace": [],
            "strengthen":
            "%(attribute)s.%(association)s.%(entity)s(strengthen)",
            "df": "%(attribute)s.%(association)s.%(entity)s(df)",
            "nonDf": "%(attribute)s.%(association)s.%(entity)s(nonDf)",
            "distinguish": "%(label)s.%(count)s"
        }
        t.sort()
        expected = """\
LOREM (_#diam.DF.SUSPENDISSE(strengthen)_, _ipsum_, dolor, sit, #elit.AMET.CONSECTETUER(df), adipiscing)
CONSECTETUER (_elit_, sed)
SOLLICITUDIN (_#diam.SOLLICITUDIN.SUSPENDISSE(nonDf)_, _#elit.SOLLICITUDIN.CONSECTETUER(nonDf)_, _#diam.SOLLICITUDIN.LOREM(nonDf)_, _#ipsum.SOLLICITUDIN.LOREM(nonDf)_, lectus)
RISUS (_ultricies_, _cras_, elementum, #ultricies.NON.RISUS(df), #cras.NON.RISUS(df))
--- SUSPENDISSE (_diam_)
MAECENAS (_#ligula.MAECENAS.DIGNISSIM(nonDf).1_, _#ligula.MAECENAS.DIGNISSIM(nonDf).2_)
DIGNISSIM (_ligula_, massa, varius, #ultricies.TORTOR.RISUS(df), #cras.TORTOR.RISUS(df), #elit.TORTOR.CONSECTETUER(df), nec)
SEMPER (_#ultricies.SEMPER.RISUS(nonDf)_, _#cras.SEMPER.RISUS(nonDf)_, _#ligula.SEMPER.DIGNISSIM(nonDf)_)"""
        self.assertEqual(t.getText(format), expected)