From 7827cd3e46e8c6294a4a610569a12523b399020c Mon Sep 17 00:00:00 2001 From: campisano Date: Wed, 16 Sep 2015 22:08:51 -0300 Subject: [PATCH 01/11] First code_generator plugin implementation: A BaseCodeGenerator interface will allow to implement specific generators. --- plugins/code_generator/README | 31 ++++ plugins/code_generator/code_generator.json | 1 + plugins/code_generator/code_generator.pro | 66 +++++++++ plugins/code_generator/res/code_generator.png | Bin 0 -> 2717 bytes .../code_generator/src/base_code_generator.h | 13 ++ plugins/code_generator/src/base_logger.h | 12 ++ .../src/code_generator_plugin.cpp | 68 +++++++++ .../src/code_generator_plugin.h | 39 +++++ .../src/code_generator_widget.cpp | 63 ++++++++ .../src/code_generator_widget.h | 33 +++++ .../ui/code_generator_widget.ui | 139 ++++++++++++++++++ plugins/plugins.pro | 2 +- 12 files changed, 466 insertions(+), 1 deletion(-) create mode 100644 plugins/code_generator/README create mode 100644 plugins/code_generator/code_generator.json create mode 100644 plugins/code_generator/code_generator.pro create mode 100644 plugins/code_generator/res/code_generator.png create mode 100644 plugins/code_generator/src/base_code_generator.h create mode 100644 plugins/code_generator/src/base_logger.h create mode 100644 plugins/code_generator/src/code_generator_plugin.cpp create mode 100644 plugins/code_generator/src/code_generator_plugin.h create mode 100644 plugins/code_generator/src/code_generator_widget.cpp create mode 100644 plugins/code_generator/src/code_generator_widget.h create mode 100644 plugins/code_generator/ui/code_generator_widget.ui diff --git a/plugins/code_generator/README b/plugins/code_generator/README new file mode 100644 index 0000000000..c9b2cd4f39 --- /dev/null +++ b/plugins/code_generator/README @@ -0,0 +1,31 @@ +# +# Created by: Riccardo Campisano riccardo.campisano AT gmail DOT com +# Original code: https://github.com/pgmodeler/pgmodeler/tree/develop/plugins/xml2object +# +# NOTE: pgmodeler plugins needs 'qttools5-dev' system package +# +### +# Example of pgmodeler compilation (under debian): +# from http://www.campisano.org/wiki/en/Postgresql#Pgmodeler : +### +# sudo apt-get install g++ pkg-config qt5-qmake qt5-default qtchooser libpq-dev libxml2-dev +# cd $HOME +# wget https://github.com/pgmodeler/pgmodeler/archive/v0.8.1.tar.gz +# tar -xzvf v0.8.1.tar.gz +# cd pgmodeler-0.8.1/ +# qmake PREFIX=$HOME/pgmodeler pgmodeler.pro +# make +# make install +# $HOME/pgmodeler/bin/pgmodeler +# +### +# Example of plugin compilation +### +# sudo apt-get install qttools5-dev +# cd $HOME/pgmodeler-0.8.1/plugins +# qmake PREFIX=$HOME/pgmodeler plugins.pro +# make +# make install +# $HOME/pgmodeler/bin/pgmodeler +# # open or generate a model and press CTRL+ALT+G +# diff --git a/plugins/code_generator/code_generator.json b/plugins/code_generator/code_generator.json new file mode 100644 index 0000000000..f85bf837ca --- /dev/null +++ b/plugins/code_generator/code_generator.json @@ -0,0 +1 @@ +{ "Keys": [ "code_generator" ] } diff --git a/plugins/code_generator/code_generator.pro b/plugins/code_generator/code_generator.pro new file mode 100644 index 0000000000..8b4e2a1842 --- /dev/null +++ b/plugins/code_generator/code_generator.pro @@ -0,0 +1,66 @@ +# code_generator.pro +# + +# Unix or Windows directory configuration +PGMODELER_SRC_DIR=../../ + +!exists($$PGMODELER_SRC_DIR) { + warning("The pgModeler source code directory '$$PGMODELER_SRC_DIR' could not be found! Make sure the variable PGMODELER_SRC_DIR points to a valid location!") + error("qmake aborted.") +} + +include(../plugins.pro) + +CONFIG += plugin qt uic4 +QT += core gui uitools +TEMPLATE = lib +TARGET = code_generator +OTHER_FILES += code_generator.json +CODECFORTR = UTF8 +DEPENDPATH = ". res src ui moc obj" +MOC_DIR = moc +OBJECTS_DIR = obj +UI_DIR = src + +windows: DESTDIR += $$PWD + +unix|windows: LIBS += -L$$OUT_PWD/../../libpgmodeler_ui/ -lpgmodeler_ui \ + -L$$OUT_PWD/../../libobjrenderer/ -lobjrenderer \ + -L$$OUT_PWD/../../libpgconnector/ -lpgconnector \ + -L$$OUT_PWD/../../libpgmodeler/ -lpgmodeler \ + -L$$OUT_PWD/../../libparsers/ -lparsers \ + -L$$OUT_PWD/../../libutils/ -lutils + +INCLUDEPATH += $$PWD/../../libpgmodeler_ui \ + $$PWD/../../libpgmodeler_ui/src \ + $$PWD/../../libobjrenderer/src \ + $$PWD/../../libpgconnector/src \ + $$PWD/../../libpgmodeler/src \ + $$PWD/../../libparsers/src \ + $$PWD/../../libutils/src + +DEPENDPATH += $$PWD/../../libpgmodeler_ui \ + $$PWD/../../libobjrenderer \ + $$PWD/../../libpgconnector \ + $$PWD/../../libpgmodeler \ + $$PWD/../../libparsers \ + $$PWD/../../libutils + +HEADERS += src/code_generator_plugin.h \ + src/code_generator_widget.h \ + src/base_code_generator.h \ + src/python_daos_generator.h \ + src/base_logger.h + +SOURCES += src/code_generator_plugin.cpp \ + src/code_generator_widget.cpp \ + src/python_daos_generator.cpp + +FORMS += ui/code_generator_widget.ui + +target.path = $$PLUGINSDIR/$$TARGET + +resources.path = $$PLUGINSDIR/$$TARGET +resources.files += res/code_generator.png lang code_generator.json + +INSTALLS += target resources diff --git a/plugins/code_generator/res/code_generator.png b/plugins/code_generator/res/code_generator.png new file mode 100644 index 0000000000000000000000000000000000000000..3108548f431e2f1f0fb7943c02b056150d40e427 GIT binary patch literal 2717 zcmV;O3S#w%P)RkUL;HU^<|$0^L=>Tm?!hpj-i+3M5w`yMntP z22YFv0*f~Yac3}@acmOAe!JKg7I!eC48S9R4S*H4WiG0LNv)qaB?qAmr@f%OcNX>>1CjN&R_Q)Y*+Q&$4cp?Jj8#7E! zY%FA-RwHAZYH)uB@Q=>RTH>BlEqn<=8C!eG*4(N-ypcSx_hof1M52=MM8q?)pl&4( zYL@kmmSln}wFz>8!FL8wENdJ+Z6!PudI#OY{3NIlfS}V+{R{KwX%|Shg0UNTWG==v zJpuSL5vh1k`2FWZYyzGee**B^_y?81+E0NfE-f#bmICz@gK#RblY*;PK|h+7LX4x7 z0X$PR7H&ZLwF4-T(v)$Z-Qy#l&!ex2eEd4l-^N5!ynGZ%NGfESR7rUq+WQI1|64+? z5RW#@0~(KwzRrPYDCy1bz+OD?aM&evy(y z)`H8^TLi$1s+8O!0I&ccxh;T8pCXvUU}XL9WB?u%0r0?LCGVE!wqaY&-!ZxeJ|ch_ zehyO}Ex)&(3Vui!<8nPR{2F!bC3CU~Iwavj+z2tqX?$Lbc)so z2%-Uii1}kiZ4KYUd&ge$?@U6%)RKDFAcz706y{$uOm|UqC3z2fSr5F7xi z%vY*!Cw?sDIgQ|NGs{x%69hp4AY=a7f;PyQ#EFis2MpTt5Q~RyvBIXRho#Fdy;kfx)>;DGpE>`sUYr^NvYj4L^w#nZej-ZaIxWn`J2h00Om{O8L1e z6)-r(J4XPBP9E1c2!I}bPb5W=4631dY}w(WggE`w2-YD>833WSf|4zICyDYM+3z$C z*TA>xj}8F7wt~S}H0f)2WY4gvoqVhQ=m6k)E1)Kabj}Hy&Mk!Mj}ic`B*8@v!B%;g zNb_wytao$(5bcG9#^Uzy*Mzax&<4A}ZZH=BACE#mZnlQ@F0<78JZxrS^^~|Tx{%FX?5S^h)6jj=e4Y^uTVuwti%z#u0L)Qq~ zgCM#spoCcltdKBYH7O%voa{Z6ElZRW$!`$=ox!_v2~#@DR&@q>1~4aTtWa7YDgYFQ z29e0%+c})~4(8=sQ`^c-xq+?0dqu9EkF;=Q=pt4KlMjjNWYAetg7QF;uc8SkTfrG_ ztAC;fz}7$lTEvr5?hN+xHo&?E0YHXJBBqt>-I=EJ`v{}jw(1K)ps8g-QO*Sb1>4_- zteZ+%b!VVVU!<05*)-E~Jw8(Wi(2a3aoGmENzk#26G$u+YQMW}m=k&nh{l zcD6p}GJwL02Ao5q$T?qH5&hg#?-aUF0sxrv=5++msrp%58 z04ftPDW;rTQRq}Z;yv6Mwo#o6IBISKsg#9JssAc~;6>FSg0cW}KNw;n0LcJgN(EA_ z`Z*sB3w1s)y2GKZffUd6aOjlu`v_`92LMy6es0IZMcdcSoeq|1fm%VG&ZR*Fu=EEY zPfEqDD?l%+?%6&*oUR#=y1Xh>98jAr>H}X3@R` zAW8tZRQ&TzS;t}5L!rXLOGKzV=TSPMi2 z09g)PRq83ysA@3Uet#`lr*nz`0K{3kRzVVYTZjsiR1T3;ip-^^k$aBID@$i@=MI33 z2!cX$5laOim|o|8&G_bOD{F{bRzqaI%_7&}ae!X3PuftUttDydBmflo{M7BM_sIMx zB7qt7i#Al;s!R}dqy|@}4sEDJEKLkp7v=5IB!g5yU{cuGX&O|8#l2X^n00lwA*u@_ zddpJJqgK-ptYE)zld27F=46lv1ZPVNF?IS#7Jt~m&8eLX;sc?sPc=nX6UYO>-eLr= z)ciKxtwSZabcX*UZPDEv`VQcCCaDkjXeec~t=iPHHj?*jI6pgBoY!|;dMK?Ne77=% zEDLu{J=9vN+cW@UBd!KWy;CT!hp(uo-&)~0NzfDkRtW=OC9pGi0C+nsXbSst6@GViL z!_N+O`r#}TFY|>R$wUVfbV{oiii`QAqj+1m>yfjNTZ2z_0Yza0MJl&`FXV^ulzxfI zfjvqDO{WRtLiXYtI~dj)-VrpxSK@?DY#bKeIHLz#ZWN=qv~SD}{Kw>_CCmctPZx4ehmpZ;l&|;? X9&S`mqxtA900000NkvXXu0mjfEV$5; literal 0 HcmV?d00001 diff --git a/plugins/code_generator/src/base_code_generator.h b/plugins/code_generator/src/base_code_generator.h new file mode 100644 index 0000000000..aa086dd886 --- /dev/null +++ b/plugins/code_generator/src/base_code_generator.h @@ -0,0 +1,13 @@ +#ifndef BASE_CODE_GENERATOR_H +#define BASE_CODE_GENERATOR_H + +#include "pgmodelerplugin.h" +#include "base_logger.h" + +class BaseCodeGenerator { + + public: + virtual void generateCode(DatabaseModel *model, BaseLogger *logger) = 0; +}; + +#endif diff --git a/plugins/code_generator/src/base_logger.h b/plugins/code_generator/src/base_logger.h new file mode 100644 index 0000000000..8f7970c474 --- /dev/null +++ b/plugins/code_generator/src/base_logger.h @@ -0,0 +1,12 @@ +#ifndef BASE_LOGGER_H +#define BASE_LOGGER_H + +#include + +class BaseLogger { + + public: + virtual void log(std::string text) = 0; +}; + +#endif diff --git a/plugins/code_generator/src/code_generator_plugin.cpp b/plugins/code_generator/src/code_generator_plugin.cpp new file mode 100644 index 0000000000..5fee831251 --- /dev/null +++ b/plugins/code_generator/src/code_generator_plugin.cpp @@ -0,0 +1,68 @@ +#include "code_generator_plugin.h" +#include "code_generator_widget.h" +#include "exception.h" +#include "messagebox.h" +#include "YOUR_SPECIFIC_generator.h" + +CodeGeneratorPlugin::CodeGeneratorPlugin(void) +{ + this->widget = new CodeGeneratorWidget(); + this->generator = new YOUR_SPECIFIC_Generator(); + ((CodeGeneratorWidget*)this->widget)->setGenerator((BaseCodeGenerator *) this->generator); + + configurePluginInfo( + getPluginTitle(), + getPluginVersion(), + getPluginAuthor(), + getPluginDescription(), + + GlobalAttributes::PLUGINS_DIR + + GlobalAttributes::DIR_SEPARATOR + + QString("code_generator") + + GlobalAttributes::DIR_SEPARATOR + QString("code_generator.png") + ); +} + +CodeGeneratorPlugin::~CodeGeneratorPlugin(void) +{ + delete ((CodeGeneratorWidget*)this->widget); + this->widget = 0; +} + +QString CodeGeneratorPlugin::getPluginTitle(void) +{ + return(trUtf8("CodeGenerator")); +} + +QString CodeGeneratorPlugin::getPluginVersion(void) +{ + return(QString("0.1")); +} + +QString CodeGeneratorPlugin::getPluginAuthor(void) +{ + return(QString("Riccardo Campisano")); +} + +QString CodeGeneratorPlugin::getPluginDescription(void) +{ + return(trUtf8("This plugin automatically gerate code.")); +} + +void CodeGeneratorPlugin::showPluginInfo(void) +{ + plugin_info_frm->show(); +} + +void CodeGeneratorPlugin::executePlugin(ModelWidget *model) +{ + if(!model) + throw Exception(trUtf8("This plugin must be executed with at least one model opened!"),ERR_CUSTOM,__PRETTY_FUNCTION__,__FILE__,__LINE__); + + ((CodeGeneratorWidget*)this->widget)->show(model->getDatabaseModel(), model->getOperationList()); +} + +QKeySequence CodeGeneratorPlugin::getPluginShortcut(void) +{ + return(QKeySequence(QString("Ctrl+Alt+G"))); +} diff --git a/plugins/code_generator/src/code_generator_plugin.h b/plugins/code_generator/src/code_generator_plugin.h new file mode 100644 index 0000000000..5167adad02 --- /dev/null +++ b/plugins/code_generator/src/code_generator_plugin.h @@ -0,0 +1,39 @@ +/** +\ingroup code_generator_plugin +\class CodeGeneratorPlugin +\brief Code generator plugin for pgModeler +*/ + +#ifndef CODE_GENERATOR_PLUGINH +#define CODE_GENERATOR_PLUGIN_H + +#include "pgmodelerplugin.h" + +class CodeGeneratorPlugin: public QObject, public PgModelerPlugin { + private: + Q_OBJECT + + Q_PLUGIN_METADATA(IID "br.com.pgmodeler.PgModelerPlugin" FILE "code_generator.json") + + //! \brief Declares the interface which is used to implement the plugin + Q_INTERFACES(PgModelerPlugin) + + void *widget; + void *generator; + + public: + CodeGeneratorPlugin(void); + ~CodeGeneratorPlugin(void); + + QString getPluginTitle(void); + QString getPluginVersion(void); + QString getPluginAuthor(void); + QString getPluginDescription(void); + QKeySequence getPluginShortcut(void); + void executePlugin(ModelWidget *); + + public slots: + void showPluginInfo(void); +}; + +#endif diff --git a/plugins/code_generator/src/code_generator_widget.cpp b/plugins/code_generator/src/code_generator_widget.cpp new file mode 100644 index 0000000000..8041a4134c --- /dev/null +++ b/plugins/code_generator/src/code_generator_widget.cpp @@ -0,0 +1,63 @@ +#include "code_generator_widget.h" + +#include + +CodeGeneratorWidget::CodeGeneratorWidget(QWidget *parent, Qt::WindowFlags f) : QDialog(parent,f) +{ + setupUi(this); + + code_hl=new SyntaxHighlighter(code_txt); + code_hl->loadConfiguration(GlobalAttributes::XML_HIGHLIGHT_CONF_PATH); + + connect(close_btn, SIGNAL(clicked(void)), this, SLOT(close(void))); + connect(clear_btn, SIGNAL(clicked(void)), this, SLOT(doClearCode(void))); + connect(generate_btn, SIGNAL(clicked(void)), this, SLOT(doGenerateCode(void))); + + this->generator = 0; +} + +void CodeGeneratorWidget::setGenerator(BaseCodeGenerator *generator) +{ + this->generator = generator; +} + +void CodeGeneratorWidget::show(DatabaseModel *model, OperationList *op_list) +{ + doClearCode(); + this->setEnabled(model!=nullptr && op_list!=nullptr); + this->op_list = op_list; + this->model = model; + QDialog::show(); +} + +void CodeGeneratorWidget::doClearCode(void) +{ + code_txt->setPlainText(QString("Ready..")); +} + +void CodeGeneratorWidget::doGenerateCode(void) +{ + try + { + if(!op_list->isOperationChainStarted()) + op_list->startOperationChain(); + + this->generator->generateCode(model, this); + + op_list->finishOperationChain(); + } + catch(Exception &e) + { + if(op_list->isOperationChainStarted()) + op_list->finishOperationChain(); + + op_list->undoOperation(); + op_list->removeLastOperation(); + throw Exception(e.getErrorMessage(), e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e); + } +} + +void CodeGeneratorWidget::log(std::string text) +{ + code_txt->setPlainText(QString::fromStdString(text)); +} diff --git a/plugins/code_generator/src/code_generator_widget.h b/plugins/code_generator/src/code_generator_widget.h new file mode 100644 index 0000000000..35fa2c65d2 --- /dev/null +++ b/plugins/code_generator/src/code_generator_widget.h @@ -0,0 +1,33 @@ +#ifndef CODE_GENERATOR_WIDGET_H +#define CODE_GENERATOR_WIDGET_H + +#include +#include "ui_code_generator_widget.h" +#include "syntaxhighlighter.h" +#include "databasemodel.h" +#include "operationlist.h" +#include "base_code_generator.h" +#include "base_logger.h" + +class CodeGeneratorWidget: public QDialog, public Ui::CodeGeneratorWidget, public BaseLogger { + private: + Q_OBJECT + SyntaxHighlighter *code_hl; + DatabaseModel *model; + OperationList *op_list; + BaseCodeGenerator *generator; + + public: + CodeGeneratorWidget(QWidget *parent = 0, Qt::WindowFlags f = 0); + void setGenerator(BaseCodeGenerator *generator); + void log(std::string text); + + public slots: + void show(DatabaseModel *model, OperationList *op_list); + + private slots: + void doClearCode(void); + void doGenerateCode(void); +}; + +#endif diff --git a/plugins/code_generator/ui/code_generator_widget.ui b/plugins/code_generator/ui/code_generator_widget.ui new file mode 100644 index 0000000000..d38ded7a93 --- /dev/null +++ b/plugins/code_generator/ui/code_generator_widget.ui @@ -0,0 +1,139 @@ + + + CodeGeneratorWidget + + + + 0 + 0 + 628 + 557 + + + + CodeGenerator + + + true + + + + 2 + + + 2 + + + 2 + + + 2 + + + 6 + + + + + Qt::Horizontal + + + + 262 + 20 + + + + + + + + + + + 30 + 0 + + + + Clear + + + + :/icones/icones/limpartexto.png:/icones/icones/limpartexto.png + + + Qt::ToolButtonTextBesideIcon + + + + + + + + 30 + 0 + + + + Generate + + + + :/icones/icones/novoobjeto.png:/icones/icones/novoobjeto.png + + + + 16 + 16 + + + + Qt::ToolButtonTextBesideIcon + + + + + + + + 30 + 0 + + + + Close + + + + :/icones/icones/fechar1.png:/icones/icones/fechar1.png + + + + 16 + 16 + + + + Qt::ToolButtonTextBesideIcon + + + + + + + + + + DejaVu Sans Mono + + + + + + + + + + + diff --git a/plugins/plugins.pro b/plugins/plugins.pro index a408ae956a..0049418fb9 100644 --- a/plugins/plugins.pro +++ b/plugins/plugins.pro @@ -5,4 +5,4 @@ include(../pgmodeler.pri) -SUBDIRS += dummy xml2object +SUBDIRS += dummy xml2object code_generator From a7e113a369d632886d02a7c75657521bf15bc1bf Mon Sep 17 00:00:00 2001 From: campisano Date: Fri, 18 Sep 2015 11:48:54 -0300 Subject: [PATCH 02/11] Added Python generator class to obtain DAOs class that implements basic CRUD first basic implementation: insert --- .../src/code_generator_plugin.cpp | 4 +- .../src/python_daos_generator.cpp | 196 ++++++++++++++++++ .../src/python_daos_generator.h | 22 ++ 3 files changed, 220 insertions(+), 2 deletions(-) create mode 100644 plugins/code_generator/src/python_daos_generator.cpp create mode 100644 plugins/code_generator/src/python_daos_generator.h diff --git a/plugins/code_generator/src/code_generator_plugin.cpp b/plugins/code_generator/src/code_generator_plugin.cpp index 5fee831251..f69704d39b 100644 --- a/plugins/code_generator/src/code_generator_plugin.cpp +++ b/plugins/code_generator/src/code_generator_plugin.cpp @@ -2,12 +2,12 @@ #include "code_generator_widget.h" #include "exception.h" #include "messagebox.h" -#include "YOUR_SPECIFIC_generator.h" +#include "python_daos_generator.h" CodeGeneratorPlugin::CodeGeneratorPlugin(void) { this->widget = new CodeGeneratorWidget(); - this->generator = new YOUR_SPECIFIC_Generator(); + this->generator = new PythonDAOsGenerator(); ((CodeGeneratorWidget*)this->widget)->setGenerator((BaseCodeGenerator *) this->generator); configurePluginInfo( diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp new file mode 100644 index 0000000000..8eb329ae4a --- /dev/null +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -0,0 +1,196 @@ +#include "python_daos_generator.h" +#include "pgmodelerplugin.h" +#include + +void PythonDAOsGenerator::generateCode(DatabaseModel *model, BaseLogger *logger) +{ + std::stringstream text; + + // loop all tables + std::vector< BaseObject * > * tables = model->getObjectList(OBJ_TABLE); + std::vector< BaseObject * >::iterator it; + + for(it = tables->begin(); it != tables->end(); ++it) + { + this->generateTable(text, (Table *)(* it)); + } + + logger->log(text.str()); +} + +// Starting code generation +void PythonDAOsGenerator::generateTable(std::stringstream &text, Table *table) +{ + // Header: + this->generateHeader(text, table); + + // Insert + this->generateInsert(text, table); + + // Update + this->generateUpdate(text, table); + + // Delete + this->generateDelete(text, table); + + // Select + this->generateSelect(text, table); +} + +std::string PythonDAOsGenerator::getDAONameFromTableName(std::string &table_name) +{ + stringstream in(table_name); + stringstream out; + + while(!in.eof()) + { + string x; + std::getline(in, x, '_' ); + + if(!x.empty()) + { + x[0] = std::toupper(x[0]); + } + + out << x; + } + + return out.str(); +} + +void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table *table) +{ + std::string table_name = table->getName().toUtf8().constData(); + std::string dao_name = this->getDAONameFromTableName(table_name); + + text << "#!/usr/bin/env python\n"; + text << "# -*- coding: utf-8 -*-\n"; + text << "\"\"\"\n"; + text << "@package " << dao_name << " Data Access Object\n"; + text << " for '" << table_name << "' table\n"; + text << "\"\"\"\n"; + text << '\n'; + text << '\n'; + text << "class " << dao_name << "():\n"; + text << '\n'; + text << " def __init__(self, database):\n"; + text << " self.db = database\n"; + text << '\n'; +} + +void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) +{ + std::string table_name = table->getName().toUtf8().constData(); + + // get primary key columns iterator to loop for all ref columns + Constraint *primary_key = table->getPrimaryKey(); + unsigned pk_num_columns = 0; + + if(primary_key) + { + pk_num_columns = primary_key->getColumnCount(Constraint::SOURCE_COLS); + } + + // get columns iterator to loop under all table columns + std::vector< TableObject * > *columns = table->getObjectList(OBJ_COLUMN); + std::vector< TableObject * >::iterator cols_it; + + // auxiliary vars + Column *column; + std::string col_name; + + // funcion definition and parameters + text << " def insert(\n"; + text << " self,\n"; + for(cols_it = columns->begin(); cols_it != columns->end(); ++cols_it) + { + column = ((Column *)(* cols_it)); + col_name = column->getName().toUtf8().constData(); + text << " " << col_name; + if(std::next(cols_it, 1) != columns->end()) text << ", "; + text << "\n"; + } + text << " ):\n"; + // commentary + text << " \"\"\" Insert a '" << table_name << "' record\n"; + text << " and get back the DB generated ID \"\"\"\n"; + text << '\n'; + // query arguments + text << " args = {\n"; + for(cols_it = columns->begin(); cols_it != columns->end(); ++cols_it) + { + column = ((Column *)(* cols_it)); + col_name = column->getName().toUtf8().constData(); + text << " \"" << col_name << "\": " << col_name; + if(std::next(cols_it, 1) != columns->end()) text << ","; + text << "\n"; + } + text << " }\n"; + text << '\n'; + // sql query + text << " sql = (\n"; + text << " \"INSERT INTO " << table_name << " (\"\n"; + for(cols_it = columns->begin(); cols_it != columns->end(); ++cols_it) + { + column = ((Column *)(* cols_it)); + col_name = column->getName().toUtf8().constData(); + text << " \"" << col_name; + if(std::next(cols_it, 1) != columns->end()) text << ", "; + text << "\"\n"; + } + text << " \") VALUES (\"\n"; + for(cols_it = columns->begin(); cols_it != columns->end(); ++cols_it) + { + column = ((Column *)(* cols_it)); + col_name = column->getName().toUtf8().constData(); + text << " \"%(" << col_name << ")s"; + if(std::next(cols_it, 1) != columns->end()) text << ", "; + text << "\"\n"; + } + text << " \")"; + if(primary_key) + { + text << " RETURNING "; + for(unsigned i = 0; igetColumn(i, Constraint::SOURCE_COLS); + col_name = column->getName().toUtf8().constData(); + text << col_name; + if(i+1 != pk_num_columns) text << ", "; + } + } + text << "\"\n"; + text << " )\n"; + text << '\n'; + // execution + text << " try:\n"; + text << " result = self.db.execute(sql, args)\n"; + if(pk_num_columns > 0) + { + text << " return dict(result.fetchone())\n"; + } + else + { + text << " result.close()\n"; + text << " return dict()\n"; + } + text << " except Exception, error:\n"; + text << " self.db.logger.error(error)\n"; + text << " raise\n"; + text << '\n'; +} + +void PythonDAOsGenerator::generateUpdate(std::stringstream &text, Table *table) +{ + +} + +void PythonDAOsGenerator::generateDelete(std::stringstream &text, Table *table) +{ + +} + +void PythonDAOsGenerator::generateSelect(std::stringstream &text, Table *table) +{ + +} diff --git a/plugins/code_generator/src/python_daos_generator.h b/plugins/code_generator/src/python_daos_generator.h new file mode 100644 index 0000000000..c30da16a10 --- /dev/null +++ b/plugins/code_generator/src/python_daos_generator.h @@ -0,0 +1,22 @@ +#ifndef PYTHON_DAOS_GENERATOR_H +#define PYTHON_DAOS_GENERATOR_H + +#include "base_code_generator.h" +#include + +class PythonDAOsGenerator: public BaseCodeGenerator { + + public: + void generateCode(DatabaseModel *model, BaseLogger *logger); + + private: + void generateTable(std::stringstream &text, Table *table); + std::string getDAONameFromTableName(std::string &table_name); + void generateHeader(std::stringstream &text, Table *table); + void generateInsert(std::stringstream &text, Table *table); + void generateUpdate(std::stringstream &text, Table *table); + void generateDelete(std::stringstream &text, Table *table); + void generateSelect(std::stringstream &text, Table *table); +}; + +#endif From c3d693bd8a62943ad36f517d8e4bbc7ffbf6f349 Mon Sep 17 00:00:00 2001 From: campisano Date: Fri, 18 Sep 2015 12:23:13 -0300 Subject: [PATCH 03/11] refactoring using vectors --- .../src/python_daos_generator.cpp | 132 +++++++++++------- .../src/python_daos_generator.h | 5 +- 2 files changed, 87 insertions(+), 50 deletions(-) diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp index 8eb329ae4a..2bc52d2502 100644 --- a/plugins/code_generator/src/python_daos_generator.cpp +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -24,40 +24,27 @@ void PythonDAOsGenerator::generateTable(std::stringstream &text, Table *table) // Header: this->generateHeader(text, table); + text << '\n'; + // Insert this->generateInsert(text, table); + text << '\n'; + // Update this->generateUpdate(text, table); + text << '\n'; + // Delete this->generateDelete(text, table); + text << '\n'; + // Select this->generateSelect(text, table); } -std::string PythonDAOsGenerator::getDAONameFromTableName(std::string &table_name) -{ - stringstream in(table_name); - stringstream out; - - while(!in.eof()) - { - string x; - std::getline(in, x, '_' ); - - if(!x.empty()) - { - x[0] = std::toupper(x[0]); - } - - out << x; - } - - return out.str(); -} - void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table *table) { std::string table_name = table->getName().toUtf8().constData(); @@ -75,25 +62,20 @@ void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table *table) text << '\n'; text << " def __init__(self, database):\n"; text << " self.db = database\n"; - text << '\n'; } void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) { + // table name std::string table_name = table->getName().toUtf8().constData(); // get primary key columns iterator to loop for all ref columns - Constraint *primary_key = table->getPrimaryKey(); - unsigned pk_num_columns = 0; - - if(primary_key) - { - pk_num_columns = primary_key->getColumnCount(Constraint::SOURCE_COLS); - } + std::vector< Column * > pk_columns = this->getTablePrimaryKeysColumns(table); + std::vector< Column * >::iterator pk_columns_it; // get columns iterator to loop under all table columns - std::vector< TableObject * > *columns = table->getObjectList(OBJ_COLUMN); - std::vector< TableObject * >::iterator cols_it; + std::vector< Column * > table_columns = this->getTableColumns(table); + std::vector< Column * >::iterator table_columns_it; // auxiliary vars Column *column; @@ -102,12 +84,12 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) // funcion definition and parameters text << " def insert(\n"; text << " self,\n"; - for(cols_it = columns->begin(); cols_it != columns->end(); ++cols_it) + for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { - column = ((Column *)(* cols_it)); + column = *table_columns_it; col_name = column->getName().toUtf8().constData(); text << " " << col_name; - if(std::next(cols_it, 1) != columns->end()) text << ", "; + if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; text << "\n"; } text << " ):\n"; @@ -117,12 +99,12 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) text << '\n'; // query arguments text << " args = {\n"; - for(cols_it = columns->begin(); cols_it != columns->end(); ++cols_it) + for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { - column = ((Column *)(* cols_it)); + column = *table_columns_it; col_name = column->getName().toUtf8().constData(); text << " \"" << col_name << "\": " << col_name; - if(std::next(cols_it, 1) != columns->end()) text << ","; + if(std::next(table_columns_it, 1) != table_columns.end()) text << ","; text << "\n"; } text << " }\n"; @@ -130,33 +112,33 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) // sql query text << " sql = (\n"; text << " \"INSERT INTO " << table_name << " (\"\n"; - for(cols_it = columns->begin(); cols_it != columns->end(); ++cols_it) + for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { - column = ((Column *)(* cols_it)); + column = *table_columns_it; col_name = column->getName().toUtf8().constData(); text << " \"" << col_name; - if(std::next(cols_it, 1) != columns->end()) text << ", "; + if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; text << "\"\n"; } text << " \") VALUES (\"\n"; - for(cols_it = columns->begin(); cols_it != columns->end(); ++cols_it) + for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { - column = ((Column *)(* cols_it)); + column = *table_columns_it; col_name = column->getName().toUtf8().constData(); text << " \"%(" << col_name << ")s"; - if(std::next(cols_it, 1) != columns->end()) text << ", "; + if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; text << "\"\n"; } text << " \")"; - if(primary_key) + if(!pk_columns.empty()) { text << " RETURNING "; - for(unsigned i = 0; igetColumn(i, Constraint::SOURCE_COLS); + column = *pk_columns_it; col_name = column->getName().toUtf8().constData(); text << col_name; - if(i+1 != pk_num_columns) text << ", "; + if(std::next(pk_columns_it, 1) != pk_columns.end()) text << ", "; } } text << "\"\n"; @@ -165,7 +147,7 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) // execution text << " try:\n"; text << " result = self.db.execute(sql, args)\n"; - if(pk_num_columns > 0) + if(!pk_columns.empty()) { text << " return dict(result.fetchone())\n"; } @@ -177,7 +159,6 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) text << " except Exception, error:\n"; text << " self.db.logger.error(error)\n"; text << " raise\n"; - text << '\n'; } void PythonDAOsGenerator::generateUpdate(std::stringstream &text, Table *table) @@ -194,3 +175,56 @@ void PythonDAOsGenerator::generateSelect(std::stringstream &text, Table *table) { } + +std::string PythonDAOsGenerator::getDAONameFromTableName(std::string &table_name) +{ + stringstream in(table_name); + stringstream out; + + while(!in.eof()) + { + string x; + std::getline(in, x, '_' ); + + if(!x.empty()) + { + x[0] = std::toupper(x[0]); + } + + out << x; + } + + return out.str(); +} + +std::vector< Column * > PythonDAOsGenerator::getTableColumns(Table *table) +{ + std::vector< Column * > table_columns; + std::vector< TableObject * > *table_objects = table->getObjectList(OBJ_COLUMN); + std::vector< TableObject * >::iterator table_objects_it; + + for(table_objects_it = table_objects->begin(); table_objects_it != table_objects->end(); ++table_objects_it) + { + table_columns.push_back((Column *)(*table_objects_it)); + } + + return table_columns; +} + +std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeysColumns(Table *table) +{ + std::vector< Column * > pk_columns; + Constraint *primary_key = table->getPrimaryKey(); + + if(primary_key) + { + unsigned pk_num_columns = primary_key->getColumnCount(Constraint::SOURCE_COLS); + + for(unsigned i = 0; igetColumn(i, Constraint::SOURCE_COLS)); + } + } + + return pk_columns; +} diff --git a/plugins/code_generator/src/python_daos_generator.h b/plugins/code_generator/src/python_daos_generator.h index c30da16a10..0540141224 100644 --- a/plugins/code_generator/src/python_daos_generator.h +++ b/plugins/code_generator/src/python_daos_generator.h @@ -11,12 +11,15 @@ class PythonDAOsGenerator: public BaseCodeGenerator { private: void generateTable(std::stringstream &text, Table *table); - std::string getDAONameFromTableName(std::string &table_name); void generateHeader(std::stringstream &text, Table *table); void generateInsert(std::stringstream &text, Table *table); void generateUpdate(std::stringstream &text, Table *table); void generateDelete(std::stringstream &text, Table *table); void generateSelect(std::stringstream &text, Table *table); + + std::string getDAONameFromTableName(std::string &table_name); + std::vector< Column * > getTableColumns(Table *table); + std::vector< Column * > getTablePrimaryKeysColumns(Table *table); }; #endif From baf392491bc6274f6b8013713641aafa23df9520 Mon Sep 17 00:00:00 2001 From: campisano Date: Fri, 18 Sep 2015 14:59:12 -0300 Subject: [PATCH 04/11] PythonDAOsGenerator: implemented select function by primary key --- .../src/python_daos_generator.cpp | 301 ++++++++++++++---- .../src/python_daos_generator.h | 6 +- 2 files changed, 242 insertions(+), 65 deletions(-) diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp index 2bc52d2502..b7c53db224 100644 --- a/plugins/code_generator/src/python_daos_generator.cpp +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -23,26 +23,23 @@ void PythonDAOsGenerator::generateTable(std::stringstream &text, Table *table) { // Header: this->generateHeader(text, table); - text << '\n'; // Insert this->generateInsert(text, table); - text << '\n'; // Update this->generateUpdate(text, table); - text << '\n'; // Delete this->generateDelete(text, table); - text << '\n'; // Select - this->generateSelect(text, table); + this->generateSelectFromPK(text, table); + text << '\n'; } void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table *table) @@ -50,18 +47,18 @@ void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table *table) std::string table_name = table->getName().toUtf8().constData(); std::string dao_name = this->getDAONameFromTableName(table_name); - text << "#!/usr/bin/env python\n"; - text << "# -*- coding: utf-8 -*-\n"; - text << "\"\"\"\n"; - text << "@package " << dao_name << " Data Access Object\n"; - text << " for '" << table_name << "' table\n"; - text << "\"\"\"\n"; + text << "#!/usr/bin/env python"; + text << "\n# -*- coding: utf-8 -*-"; + text << "\n\"\"\""; + text << "\n@package " << dao_name << " Data Access Object"; + text << "\n for '" << table_name << "' table"; + text << "\n\"\"\""; text << '\n'; text << '\n'; - text << "class " << dao_name << "():\n"; + text << "\nclass " << dao_name << "():"; text << '\n'; - text << " def __init__(self, database):\n"; - text << " self.db = database\n"; + text << "\n def __init__(self, database):"; + text << "\n self.db = database"; } void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) @@ -69,67 +66,125 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) // table name std::string table_name = table->getName().toUtf8().constData(); - // get primary key columns iterator to loop for all ref columns - std::vector< Column * > pk_columns = this->getTablePrimaryKeysColumns(table); - std::vector< Column * >::iterator pk_columns_it; - - // get columns iterator to loop under all table columns + // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); std::vector< Column * >::iterator table_columns_it; + // get primary key columns and iterator + std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); + std::vector< Column * >::iterator pk_columns_it; + + // get primary key columns that have a sequence + std::vector< Column * > pk_auto_columns = this->getTablePrimaryKeyAutoColumns(table); + std::vector< Column * >::iterator pk_auto_columns_it; + // auxiliary vars Column *column; std::string col_name; + bool is_auto_pk; + bool is_first_column_writed; // funcion definition and parameters - text << " def insert(\n"; - text << " self,\n"; + text << "\n def insert("; + text << "\n self"; + is_first_column_writed = true; // already write self above for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { - column = *table_columns_it; - col_name = column->getName().toUtf8().constData(); - text << " " << col_name; - if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; - text << "\n"; + is_auto_pk = std::find(pk_auto_columns.begin(), pk_auto_columns.end(), *table_columns_it) != pk_auto_columns.end(); + if(! is_auto_pk) + { + column = *table_columns_it; + col_name = column->getName().toUtf8().constData(); + if(!is_first_column_writed) + { + text << '\n'; + is_first_column_writed = true; + } + else + { + text << ",\n"; + } + text << " " << col_name; + } } - text << " ):\n"; + text << "\n ):"; + // commentary - text << " \"\"\" Insert a '" << table_name << "' record\n"; - text << " and get back the DB generated ID \"\"\"\n"; + text << "\n \"\"\" Insert a '" << table_name << "' record"; + text << "\n and get back the DB generated ID \"\"\""; text << '\n'; + // query arguments - text << " args = {\n"; + text << "\n args = {"; + is_first_column_writed = false; for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { - column = *table_columns_it; - col_name = column->getName().toUtf8().constData(); - text << " \"" << col_name << "\": " << col_name; - if(std::next(table_columns_it, 1) != table_columns.end()) text << ","; - text << "\n"; + is_auto_pk = std::find(pk_auto_columns.begin(), pk_auto_columns.end(), *table_columns_it) != pk_auto_columns.end(); + if(! is_auto_pk) + { + column = *table_columns_it; + col_name = column->getName().toUtf8().constData(); + if(!is_first_column_writed) + { + text << '\n'; + is_first_column_writed = true; + } + else + { + text << ",\n"; + } + text << " \"" << col_name << "\": " << col_name; + } } - text << " }\n"; - text << '\n'; + text << "\n }\n"; + // sql query - text << " sql = (\n"; - text << " \"INSERT INTO " << table_name << " (\"\n"; + text << "\n sql = ("; + text << "\n \"INSERT INTO " << table_name << " ("; + is_first_column_writed = false; for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { - column = *table_columns_it; - col_name = column->getName().toUtf8().constData(); - text << " \"" << col_name; - if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; - text << "\"\n"; + is_auto_pk = std::find(pk_auto_columns.begin(), pk_auto_columns.end(), *table_columns_it) != pk_auto_columns.end(); + if(! is_auto_pk) + { + column = *table_columns_it; + col_name = column->getName().toUtf8().constData(); + if(!is_first_column_writed) + { + text << "\"\n"; + is_first_column_writed = true; + } + else + { + text << ", \"\n"; + } + text << " \"" << col_name; + } } - text << " \") VALUES (\"\n"; + text << '\"'; + text << "\n \") VALUES ("; + is_first_column_writed = false; for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { - column = *table_columns_it; - col_name = column->getName().toUtf8().constData(); - text << " \"%(" << col_name << ")s"; - if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; - text << "\"\n"; + is_auto_pk = std::find(pk_auto_columns.begin(), pk_auto_columns.end(), *table_columns_it) != pk_auto_columns.end(); + if(! is_auto_pk) + { + column = *table_columns_it; + col_name = column->getName().toUtf8().constData(); + if(!is_first_column_writed) + { + text << "\"\n"; + is_first_column_writed = true; + } + else + { + text << ", \"\n"; + } + text << " \"%(" << col_name << ")s"; + } } - text << " \")"; + text << '\"'; + text << "\n \")"; if(!pk_columns.empty()) { text << " RETURNING "; @@ -141,24 +196,24 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) if(std::next(pk_columns_it, 1) != pk_columns.end()) text << ", "; } } - text << "\"\n"; - text << " )\n"; + text << '\"'; + text << "\n )"; text << '\n'; // execution - text << " try:\n"; - text << " result = self.db.execute(sql, args)\n"; + text << "\n try:"; + text << "\n result = self.db.execute(sql, args)"; if(!pk_columns.empty()) { - text << " return dict(result.fetchone())\n"; + text << "\n return dict(result.fetchone())"; } else { - text << " result.close()\n"; - text << " return dict()\n"; + text << "\n result.close()"; + text << "\n return dict()"; } - text << " except Exception, error:\n"; - text << " self.db.logger.error(error)\n"; - text << " raise\n"; + text << "\n except Exception, error:"; + text << "\n self.db.logger.error(error)"; + text << "\n raise"; } void PythonDAOsGenerator::generateUpdate(std::stringstream &text, Table *table) @@ -171,9 +226,91 @@ void PythonDAOsGenerator::generateDelete(std::stringstream &text, Table *table) } -void PythonDAOsGenerator::generateSelect(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table *table) { + // table name + std::string table_name = table->getName().toUtf8().constData(); + + // get table columns and iterator to loop under all table columns + std::vector< Column * > table_columns = this->getTableColumns(table); + std::vector< Column * >::iterator table_columns_it; + + // get primary key columns and iterator + std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); + std::vector< Column * >::iterator pk_columns_it; + + if(pk_columns.empty()) + { + return; // will be no select from pk + } + + std::string pk_names = this->getTablePrimaryKeyNames(pk_columns); + + // auxiliary vars + Column *column; + std::string col_name; + // funcion definition and parameters + text << "\n def select_by_" << pk_names << "("; + text << "\n self,"; + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + column = *pk_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n " << col_name; + if(std::next(pk_columns_it, 1) != pk_columns.end()) text << ','; + } + text << "\n ):"; + + // commentary + text << "\n \"\"\" Retreive a '" << table_name << "' record"; + text << "\n using primary key \"\"\""; + text << '\n'; + + // query arguments + text << "\n args = {"; + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + column = *pk_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n \"" << col_name << "\": " << col_name; + if(std::next(pk_columns_it, 1) != pk_columns.end()) text << ','; + } + text << "\n }"; + text << '\n'; + + // sql query + text << "\n sql = ("; + text << "\n \"SELECT \""; + for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) + { + column = *table_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n \"" << col_name; + if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; + text << '\"'; + } + text << "\n \" FROM " << table_name << " WHERE \""; + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + column = *pk_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n \"" << col_name << " = %(" << col_name << ")s"; + if(std::next(pk_columns_it, 1) != pk_columns.end()) text << " AND "; + text << '\"'; + } + text << "\n )"; + text << '\n'; + // execution + text << "\n try:"; + text << "\n result = self.db.execute(sql, args)"; + text << "\n results = []"; + text << "\n for row in result:"; + text << "\n results.append(dict(zip(row.keys(), row.values())))"; + text << "\n return results"; + text << "\n except Exception, error:"; + text << "\n self.db.logger.error(error)"; + text << "\n raise"; } std::string PythonDAOsGenerator::getDAONameFromTableName(std::string &table_name) @@ -211,7 +348,7 @@ std::vector< Column * > PythonDAOsGenerator::getTableColumns(Table *table) return table_columns; } -std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeysColumns(Table *table) +std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyColumns(Table *table) { std::vector< Column * > pk_columns; Constraint *primary_key = table->getPrimaryKey(); @@ -228,3 +365,41 @@ std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeysColumns(Table *t return pk_columns; } + +std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyAutoColumns(Table *table) +{ + std::vector< Column * > pk_columns; + Constraint *primary_key = table->getPrimaryKey(); + Column *column; + + if(primary_key) + { + unsigned pk_num_columns = primary_key->getColumnCount(Constraint::SOURCE_COLS); + + for(unsigned i = 0; igetColumn(i, Constraint::SOURCE_COLS); + + if(column->getSequence() == nullptr) + { + pk_columns.push_back(column); + } + } + } + + return pk_columns; +} + +std::string PythonDAOsGenerator::getTablePrimaryKeyNames(std::vector< Column * > &pk_columns) +{ + std::string pk_names; + std::vector< Column * >::iterator pk_columns_it; + + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + pk_names += (*pk_columns_it)->getName().toUtf8().constData(); + if(std::next(pk_columns_it, 1) != pk_columns.end()) pk_names += "_"; + } + + return pk_names; +} diff --git a/plugins/code_generator/src/python_daos_generator.h b/plugins/code_generator/src/python_daos_generator.h index 0540141224..f838010b59 100644 --- a/plugins/code_generator/src/python_daos_generator.h +++ b/plugins/code_generator/src/python_daos_generator.h @@ -15,11 +15,13 @@ class PythonDAOsGenerator: public BaseCodeGenerator { void generateInsert(std::stringstream &text, Table *table); void generateUpdate(std::stringstream &text, Table *table); void generateDelete(std::stringstream &text, Table *table); - void generateSelect(std::stringstream &text, Table *table); + void generateSelectFromPK(std::stringstream &text, Table *table); std::string getDAONameFromTableName(std::string &table_name); std::vector< Column * > getTableColumns(Table *table); - std::vector< Column * > getTablePrimaryKeysColumns(Table *table); + std::vector< Column * > getTablePrimaryKeyColumns(Table *table); + std::vector< Column * > getTablePrimaryKeyAutoColumns(Table *table); + std::string getTablePrimaryKeyNames(std::vector< Column * > &pk_columns); }; #endif From 8e9e03c4b57a85dc50d0f251a3cd0ec379ebad2f Mon Sep 17 00:00:00 2001 From: campisano Date: Mon, 21 Sep 2015 12:54:23 -0300 Subject: [PATCH 05/11] PythonDAOsGenerator: first complete version with all CRUDs operations ('insert', 'select', 'update' and 'delete'), using Primary key as record identifiers. --- .../src/python_daos_generator.cpp | 191 +++++++++++++++++- .../src/python_daos_generator.h | 4 +- 2 files changed, 183 insertions(+), 12 deletions(-) diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp index b7c53db224..a06109ea24 100644 --- a/plugins/code_generator/src/python_daos_generator.cpp +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -30,11 +30,11 @@ void PythonDAOsGenerator::generateTable(std::stringstream &text, Table *table) text << '\n'; // Update - this->generateUpdate(text, table); + this->generateUpdateFromPK(text, table); text << '\n'; // Delete - this->generateDelete(text, table); + this->generateDeleteFromPK(text, table); text << '\n'; // Select @@ -136,7 +136,10 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) text << " \"" << col_name << "\": " << col_name; } } - text << "\n }\n"; + text << "\n }"; + text << '\n'; + + //TODO [CMP] put \n at the start of the line // sql query text << "\n sql = ("; @@ -216,14 +219,176 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) text << "\n raise"; } -void PythonDAOsGenerator::generateUpdate(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table *table) { + // table name + std::string table_name = table->getName().toUtf8().constData(); + + // get table columns and iterator to loop under all table columns + std::vector< Column * > table_columns = this->getTableColumns(table); + std::vector< Column * >::iterator table_columns_it; + + // get primary key columns and iterator + std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); + std::vector< Column * >::iterator pk_columns_it; + + if(pk_columns.empty()) + { + return; // will be no update from pk + } + + std::string pk_names = this->getTablePrimaryKeyNames(pk_columns); + + // auxiliary vars + Column *column; + std::string col_name; + bool is_pk; + + // funcion definition and parameters + text << "\n def update_by_" << pk_names << "("; + text << "\n self,"; + // pk first + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + column = *pk_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n " << col_name; + if(!table_columns.empty() || std::next(pk_columns_it, 1) != pk_columns.end()) text << ','; + } + // then the rest + for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) + { + is_pk = std::find(pk_columns.begin(), pk_columns.end(), *table_columns_it) != pk_columns.end(); + if(! is_pk) + { + column = *table_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n " << col_name; + if(std::next(table_columns_it, 1) != table_columns.end()) text << ','; + } + } + text << "\n ):"; + + // commentary + text << "\n \"\"\" Update a '" << table_name << "' record"; + text << "\n using primary key \"\"\""; + text << '\n'; + + // query arguments + text << "\n args = {"; + for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) + { + column = *table_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n \"" << col_name << "\": " << col_name; + if(std::next(table_columns_it, 1) != table_columns.end()) text << ','; + } + text << "\n }"; + text << '\n'; + // sql query + text << "\n sql = ("; + text << "\n \"UPDATE " << table_name << " SET \""; + for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) + { + column = *table_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n \"" << col_name << " = %(" << col_name << ")s"; + if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; + text << '\"'; + } + text << "\n \" WHERE \""; + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + column = *pk_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n \"" << col_name << " = %(" << col_name << ")s"; + if(std::next(pk_columns_it, 1) != pk_columns.end()) text << " AND "; + text << '\"'; + } + text << "\n )"; + text << '\n'; + // execution + text << "\n try:"; + text << "\n result = self.db.execute(sql, args)"; + text << "\n result.close()"; + text << "\n return result.rowcount"; + text << "\n except Exception, error:"; + text << "\n self.db.logger.error(error)"; + text << "\n raise"; } -void PythonDAOsGenerator::generateDelete(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table *table) { + // table name + std::string table_name = table->getName().toUtf8().constData(); + + // get primary key columns and iterator + std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); + std::vector< Column * >::iterator pk_columns_it; + + if(pk_columns.empty()) + { + return; // will be no delete from pk + } + + std::string pk_names = this->getTablePrimaryKeyNames(pk_columns); + + // auxiliary vars + Column *column; + std::string col_name; + + // funcion definition and parameters + text << "\n def delete_by_" << pk_names << "("; + text << "\n self,"; + // pk first + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + column = *pk_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n " << col_name; + if(std::next(pk_columns_it, 1) != pk_columns.end()) text << ','; + } + text << "\n ):"; + // commentary + text << "\n \"\"\" Delete a '" << table_name << "' record"; + text << "\n using primary key \"\"\""; + text << '\n'; + + // query arguments + text << "\n args = {"; + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + column = *pk_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n \"" << col_name << "\": " << col_name; + if(std::next(pk_columns_it, 1) != pk_columns.end()) text << ','; + } + text << "\n }"; + text << '\n'; + + // sql query + text << "\n sql = ("; + text << "\n \"DELETE FROM " << table_name << " WHERE \""; + for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + { + column = *pk_columns_it; + col_name = column->getName().toUtf8().constData(); + text << "\n \"" << col_name << " = %(" << col_name << ")s"; + if(std::next(pk_columns_it, 1) != pk_columns.end()) text << " AND "; + text << '\"'; + } + text << "\n )"; + text << '\n'; + // execution + text << "\n try:"; + text << "\n result = self.db.execute(sql, args)"; + text << "\n result.close()"; + text << "\n return result.rowcount"; + text << "\n except Exception, error:"; + text << "\n self.db.logger.error(error)"; + text << "\n raise"; } void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table *table) @@ -303,11 +468,17 @@ void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table *t text << '\n'; // execution text << "\n try:"; - text << "\n result = self.db.execute(sql, args)"; - text << "\n results = []"; - text << "\n for row in result:"; - text << "\n results.append(dict(zip(row.keys(), row.values())))"; - text << "\n return results"; + text << "\n results = self.db.execute(sql, args)"; + text << "\n if results.rowcount > 1:"; + text << "\n raise RuntimeError("; + text << "\n \"ERROR: Select by primary key returned multiple rows!\")"; + text << "\n if results.rowcount == 1:"; + text << "\n row = results.fetchone()"; + text << "\n result = dict(zip(row.keys(), row.values()))"; + text << "\n else:"; + text << "\n result = None"; + text << "\n results.close()"; + text << "\n return result"; text << "\n except Exception, error:"; text << "\n self.db.logger.error(error)"; text << "\n raise"; diff --git a/plugins/code_generator/src/python_daos_generator.h b/plugins/code_generator/src/python_daos_generator.h index f838010b59..6be728e3c0 100644 --- a/plugins/code_generator/src/python_daos_generator.h +++ b/plugins/code_generator/src/python_daos_generator.h @@ -13,8 +13,8 @@ class PythonDAOsGenerator: public BaseCodeGenerator { void generateTable(std::stringstream &text, Table *table); void generateHeader(std::stringstream &text, Table *table); void generateInsert(std::stringstream &text, Table *table); - void generateUpdate(std::stringstream &text, Table *table); - void generateDelete(std::stringstream &text, Table *table); + void generateUpdateFromPK(std::stringstream &text, Table *table); + void generateDeleteFromPK(std::stringstream &text, Table *table); void generateSelectFromPK(std::stringstream &text, Table *table); std::string getDAONameFromTableName(std::string &table_name); From b44b6349c303711c1dab717dc11eb52d0835a40f Mon Sep 17 00:00:00 2001 From: campisano Date: Tue, 22 Sep 2015 16:00:49 -0300 Subject: [PATCH 06/11] PythonDAOsGenerator: implemented generation of SELECT method for each Unique key --- .../src/python_daos_generator.cpp | 112 ++++++++++++++---- .../src/python_daos_generator.h | 7 +- 2 files changed, 94 insertions(+), 25 deletions(-) diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp index a06109ea24..dcebb2ca1b 100644 --- a/plugins/code_generator/src/python_daos_generator.cpp +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -23,22 +23,23 @@ void PythonDAOsGenerator::generateTable(std::stringstream &text, Table *table) { // Header: this->generateHeader(text, table); - text << '\n'; // Insert this->generateInsert(text, table); - text << '\n'; // Update this->generateUpdateFromPK(text, table); - text << '\n'; // Delete this->generateDeleteFromPK(text, table); - text << '\n'; // Select this->generateSelectFromPK(text, table); + + // Select + this->generateSelectFromUKs(text, table); + + // end newline text << '\n'; } @@ -85,6 +86,7 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) bool is_first_column_writed; // funcion definition and parameters + text << '\n'; text << "\n def insert("; text << "\n self"; is_first_column_writed = true; // already write self above @@ -237,7 +239,7 @@ void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table *t return; // will be no update from pk } - std::string pk_names = this->getTablePrimaryKeyNames(pk_columns); + std::string pk_names = this->getKeyNamesFromColumns(pk_columns); // auxiliary vars Column *column; @@ -245,6 +247,7 @@ void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table *t bool is_pk; // funcion definition and parameters + text << '\n'; text << "\n def update_by_" << pk_names << "("; text << "\n self,"; // pk first @@ -332,13 +335,14 @@ void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table *t return; // will be no delete from pk } - std::string pk_names = this->getTablePrimaryKeyNames(pk_columns); + std::string pk_names = this->getKeyNamesFromColumns(pk_columns); // auxiliary vars Column *column; std::string col_name; // funcion definition and parameters + text << '\n'; text << "\n def delete_by_" << pk_names << "("; text << "\n self,"; // pk first @@ -398,48 +402,74 @@ void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table *t // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); - std::vector< Column * >::iterator table_columns_it; // get primary key columns and iterator std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); - std::vector< Column * >::iterator pk_columns_it; - if(pk_columns.empty()) + // generate for pk + generateSelectFromConstraintColumns(text, table_name, table_columns, pk_columns); +} + +void PythonDAOsGenerator::generateSelectFromUKs(std::stringstream &text, Table *table) +{ + // table name + std::string table_name = table->getName().toUtf8().constData(); + + // get table columns and iterator to loop under all table columns + std::vector< Column * > table_columns = this->getTableColumns(table); + + // get all unique keys + std::vector< std::vector< Column * > > uk_keys = getTableUniqueKeyColumns(table); + std::vector< std::vector< Column * > >::iterator uk_keys_it; + + // generate for all uk + for(uk_keys_it = uk_keys.begin(); uk_keys_it != uk_keys.end(); ++uk_keys_it) { - return; // will be no select from pk + generateSelectFromConstraintColumns(text, table_name, table_columns, *uk_keys_it); } +} - std::string pk_names = this->getTablePrimaryKeyNames(pk_columns); +void PythonDAOsGenerator::generateSelectFromConstraintColumns(std::stringstream &text, std::string &table_name, std::vector< Column * > &table_columns, std::vector< Column * > &constr_columns) +{ + if(constr_columns.empty()) + { + return; // will be no select from this primary/unique key + } + + std::vector< Column * >::iterator table_columns_it; + std::vector< Column * >::iterator constr_columns_it; + std::string constr_names = this->getKeyNamesFromColumns(constr_columns); // auxiliary vars Column *column; std::string col_name; // funcion definition and parameters - text << "\n def select_by_" << pk_names << "("; + text << '\n'; + text << "\n def select_by_" << constr_names << "("; text << "\n self,"; - for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + for(constr_columns_it = constr_columns.begin(); constr_columns_it != constr_columns.end(); ++constr_columns_it) { - column = *pk_columns_it; + column = *constr_columns_it; col_name = column->getName().toUtf8().constData(); text << "\n " << col_name; - if(std::next(pk_columns_it, 1) != pk_columns.end()) text << ','; + if(std::next(constr_columns_it, 1) != constr_columns.end()) text << ','; } text << "\n ):"; // commentary text << "\n \"\"\" Retreive a '" << table_name << "' record"; - text << "\n using primary key \"\"\""; + text << "\n using primary or unique key \"\"\""; text << '\n'; // query arguments text << "\n args = {"; - for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + for(constr_columns_it = constr_columns.begin(); constr_columns_it != constr_columns.end(); ++constr_columns_it) { - column = *pk_columns_it; + column = *constr_columns_it; col_name = column->getName().toUtf8().constData(); text << "\n \"" << col_name << "\": " << col_name; - if(std::next(pk_columns_it, 1) != pk_columns.end()) text << ','; + if(std::next(constr_columns_it, 1) != constr_columns.end()) text << ','; } text << "\n }"; text << '\n'; @@ -456,12 +486,12 @@ void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table *t text << '\"'; } text << "\n \" FROM " << table_name << " WHERE \""; - for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) + for(constr_columns_it = constr_columns.begin(); constr_columns_it != constr_columns.end(); ++constr_columns_it) { - column = *pk_columns_it; + column = *constr_columns_it; col_name = column->getName().toUtf8().constData(); text << "\n \"" << col_name << " = %(" << col_name << ")s"; - if(std::next(pk_columns_it, 1) != pk_columns.end()) text << " AND "; + if(std::next(constr_columns_it, 1) != constr_columns.end()) text << " AND "; text << '\"'; } text << "\n )"; @@ -471,7 +501,8 @@ void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table *t text << "\n results = self.db.execute(sql, args)"; text << "\n if results.rowcount > 1:"; text << "\n raise RuntimeError("; - text << "\n \"ERROR: Select by primary key returned multiple rows!\")"; + text << "\n \"ERROR: Select by primary/unique key\""; + text << "\n \"returned multiple rows!\")"; text << "\n if results.rowcount == 1:"; text << "\n row = results.fetchone()"; text << "\n result = dict(zip(row.keys(), row.values()))"; @@ -561,7 +592,40 @@ std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyAutoColumns(Table return pk_columns; } -std::string PythonDAOsGenerator::getTablePrimaryKeyNames(std::vector< Column * > &pk_columns) +std::vector< std::vector< Column * > > PythonDAOsGenerator::getTableUniqueKeyColumns(Table *table) +{ + std::vector< std::vector< Column * > > uk_columns; + + std::vector< TableObject * > *table_objects = table->getObjectList(OBJ_CONSTRAINT); + std::vector< TableObject * >::iterator table_objects_it; + + Constraint* unique_key; + unsigned uk_num_columns; + + for(table_objects_it = table_objects->begin(); table_objects_it != table_objects->end(); ++table_objects_it) + { + unique_key = (Constraint *)(*table_objects_it); + + if(unique_key->getConstraintType() == ConstraintType::unique) + { + uk_num_columns = unique_key->getColumnCount(Constraint::SOURCE_COLS); + + if(uk_num_columns > 0) + { + std::vector< Column * > columns; + for(unsigned i = 0; igetColumn(i, Constraint::SOURCE_COLS)); + } + uk_columns.push_back(columns); + } + } + } + + return uk_columns; +} + +std::string PythonDAOsGenerator::getKeyNamesFromColumns(std::vector< Column * > &pk_columns) { std::string pk_names; std::vector< Column * >::iterator pk_columns_it; diff --git a/plugins/code_generator/src/python_daos_generator.h b/plugins/code_generator/src/python_daos_generator.h index 6be728e3c0..4af47d40cb 100644 --- a/plugins/code_generator/src/python_daos_generator.h +++ b/plugins/code_generator/src/python_daos_generator.h @@ -3,6 +3,8 @@ #include "base_code_generator.h" #include +#include +#include class PythonDAOsGenerator: public BaseCodeGenerator { @@ -16,12 +18,15 @@ class PythonDAOsGenerator: public BaseCodeGenerator { void generateUpdateFromPK(std::stringstream &text, Table *table); void generateDeleteFromPK(std::stringstream &text, Table *table); void generateSelectFromPK(std::stringstream &text, Table *table); + void generateSelectFromUKs(std::stringstream &text, Table *table); + void generateSelectFromConstraintColumns(std::stringstream &text, std::string &table_name, std::vector< Column * > &table_columns, std::vector< Column * > &constr_columns); std::string getDAONameFromTableName(std::string &table_name); std::vector< Column * > getTableColumns(Table *table); std::vector< Column * > getTablePrimaryKeyColumns(Table *table); std::vector< Column * > getTablePrimaryKeyAutoColumns(Table *table); - std::string getTablePrimaryKeyNames(std::vector< Column * > &pk_columns); + std::vector< std::vector< Column * > > getTableUniqueKeyColumns(Table *table); + std::string getKeyNamesFromColumns(std::vector< Column * > &pk_columns); }; #endif From c4ae48ce3378fd48e3b63672c1d2ac2072bf4183 Mon Sep 17 00:00:00 2001 From: campisano Date: Tue, 22 Sep 2015 23:41:42 -0300 Subject: [PATCH 07/11] PythonDAOsGenerator: implemented creation of separated python DAO archives. --- .../code_generator/src/base_code_generator.h | 6 +- .../src/code_generator_widget.cpp | 15 ++++- .../src/python_daos_generator.cpp | 63 ++++++++++--------- .../src/python_daos_generator.h | 25 ++++---- 4 files changed, 66 insertions(+), 43 deletions(-) diff --git a/plugins/code_generator/src/base_code_generator.h b/plugins/code_generator/src/base_code_generator.h index aa086dd886..85ecb92f20 100644 --- a/plugins/code_generator/src/base_code_generator.h +++ b/plugins/code_generator/src/base_code_generator.h @@ -1,13 +1,15 @@ #ifndef BASE_CODE_GENERATOR_H #define BASE_CODE_GENERATOR_H -#include "pgmodelerplugin.h" #include "base_logger.h" +#include "pgmodelerplugin.h" +#include +#include class BaseCodeGenerator { public: - virtual void generateCode(DatabaseModel *model, BaseLogger *logger) = 0; + virtual void generateCode(DatabaseModel &model, BaseLogger &logger, std::map< std::string, std::string > &files_to_generate) = 0; }; #endif diff --git a/plugins/code_generator/src/code_generator_widget.cpp b/plugins/code_generator/src/code_generator_widget.cpp index 8041a4134c..915ef83ea2 100644 --- a/plugins/code_generator/src/code_generator_widget.cpp +++ b/plugins/code_generator/src/code_generator_widget.cpp @@ -1,5 +1,8 @@ #include "code_generator_widget.h" +#include +#include +#include #include CodeGeneratorWidget::CodeGeneratorWidget(QWidget *parent, Qt::WindowFlags f) : QDialog(parent,f) @@ -37,12 +40,22 @@ void CodeGeneratorWidget::doClearCode(void) void CodeGeneratorWidget::doGenerateCode(void) { + std::map< std::string, std::string > files_to_generate; + std::map< std::string, std::string >::iterator it; + try { if(!op_list->isOperationChainStarted()) op_list->startOperationChain(); - this->generator->generateCode(model, this); + this->generator->generateCode(*model, *this, files_to_generate); + + for(it = files_to_generate.begin(); it != files_to_generate.end(); ++it) + { + std::ofstream out_file("/tmp/" + it->first); + out_file << it->second; + out_file.close(); + } op_list->finishOperationChain(); } diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp index dcebb2ca1b..a49ed5ef34 100644 --- a/plugins/code_generator/src/python_daos_generator.cpp +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -2,25 +2,30 @@ #include "pgmodelerplugin.h" #include -void PythonDAOsGenerator::generateCode(DatabaseModel *model, BaseLogger *logger) +void PythonDAOsGenerator::generateCode(DatabaseModel &model, BaseLogger &logger, std::map< std::string, std::string > &files_to_generate) { - std::stringstream text; - // loop all tables - std::vector< BaseObject * > * tables = model->getObjectList(OBJ_TABLE); + std::vector< BaseObject * > * tables = model.getObjectList(OBJ_TABLE); std::vector< BaseObject * >::iterator it; + std::string schema_name; + std::string table_name; + std::string table_code; for(it = tables->begin(); it != tables->end(); ++it) { - this->generateTable(text, (Table *)(* it)); + schema_name = (*it)->getSchema()->getName().toUtf8().constData(); + table_name = (*it)->getName().toUtf8().constData(); + table_code = this->generateCompleteTableCode(*(Table *)(* it)); + files_to_generate[schema_name + "_" + table_name + ".py"] = table_code; + logger.log(table_code); } - - logger->log(text.str()); } // Starting code generation -void PythonDAOsGenerator::generateTable(std::stringstream &text, Table *table) +std::string PythonDAOsGenerator::generateCompleteTableCode(Table &table) { + std::stringstream text; + // Header: this->generateHeader(text, table); @@ -41,11 +46,13 @@ void PythonDAOsGenerator::generateTable(std::stringstream &text, Table *table) // end newline text << '\n'; + + return text.str(); } -void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table &table) { - std::string table_name = table->getName().toUtf8().constData(); + std::string table_name = table.getName().toUtf8().constData(); std::string dao_name = this->getDAONameFromTableName(table_name); text << "#!/usr/bin/env python"; @@ -62,10 +69,10 @@ void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table *table) text << "\n self.db = database"; } -void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table) { // table name - std::string table_name = table->getName().toUtf8().constData(); + std::string table_name = table.getName().toUtf8().constData(); // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); @@ -221,10 +228,10 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table *table) text << "\n raise"; } -void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table &table) { // table name - std::string table_name = table->getName().toUtf8().constData(); + std::string table_name = table.getName().toUtf8().constData(); // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); @@ -321,10 +328,10 @@ void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table *t text << "\n raise"; } -void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table &table) { // table name - std::string table_name = table->getName().toUtf8().constData(); + std::string table_name = table.getName().toUtf8().constData(); // get primary key columns and iterator std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); @@ -395,10 +402,10 @@ void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table *t text << "\n raise"; } -void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table &table) { // table name - std::string table_name = table->getName().toUtf8().constData(); + std::string table_name = table.getName().toUtf8().constData(); // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); @@ -410,10 +417,10 @@ void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table *t generateSelectFromConstraintColumns(text, table_name, table_columns, pk_columns); } -void PythonDAOsGenerator::generateSelectFromUKs(std::stringstream &text, Table *table) +void PythonDAOsGenerator::generateSelectFromUKs(std::stringstream &text, Table &table) { // table name - std::string table_name = table->getName().toUtf8().constData(); + std::string table_name = table.getName().toUtf8().constData(); // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); @@ -536,10 +543,10 @@ std::string PythonDAOsGenerator::getDAONameFromTableName(std::string &table_name return out.str(); } -std::vector< Column * > PythonDAOsGenerator::getTableColumns(Table *table) +std::vector< Column * > PythonDAOsGenerator::getTableColumns(Table &table) { std::vector< Column * > table_columns; - std::vector< TableObject * > *table_objects = table->getObjectList(OBJ_COLUMN); + std::vector< TableObject * > *table_objects = table.getObjectList(OBJ_COLUMN); std::vector< TableObject * >::iterator table_objects_it; for(table_objects_it = table_objects->begin(); table_objects_it != table_objects->end(); ++table_objects_it) @@ -550,10 +557,10 @@ std::vector< Column * > PythonDAOsGenerator::getTableColumns(Table *table) return table_columns; } -std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyColumns(Table *table) +std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyColumns(Table &table) { std::vector< Column * > pk_columns; - Constraint *primary_key = table->getPrimaryKey(); + Constraint *primary_key = table.getPrimaryKey(); if(primary_key) { @@ -568,10 +575,10 @@ std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyColumns(Table *ta return pk_columns; } -std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyAutoColumns(Table *table) +std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyAutoColumns(Table &table) { std::vector< Column * > pk_columns; - Constraint *primary_key = table->getPrimaryKey(); + Constraint *primary_key = table.getPrimaryKey(); Column *column; if(primary_key) @@ -592,11 +599,11 @@ std::vector< Column * > PythonDAOsGenerator::getTablePrimaryKeyAutoColumns(Table return pk_columns; } -std::vector< std::vector< Column * > > PythonDAOsGenerator::getTableUniqueKeyColumns(Table *table) +std::vector< std::vector< Column * > > PythonDAOsGenerator::getTableUniqueKeyColumns(Table &table) { std::vector< std::vector< Column * > > uk_columns; - std::vector< TableObject * > *table_objects = table->getObjectList(OBJ_CONSTRAINT); + std::vector< TableObject * > *table_objects = table.getObjectList(OBJ_CONSTRAINT); std::vector< TableObject * >::iterator table_objects_it; Constraint* unique_key; diff --git a/plugins/code_generator/src/python_daos_generator.h b/plugins/code_generator/src/python_daos_generator.h index 4af47d40cb..b97e177b7c 100644 --- a/plugins/code_generator/src/python_daos_generator.h +++ b/plugins/code_generator/src/python_daos_generator.h @@ -9,23 +9,24 @@ class PythonDAOsGenerator: public BaseCodeGenerator { public: - void generateCode(DatabaseModel *model, BaseLogger *logger); + void generateCode(DatabaseModel &model, BaseLogger &logger, std::map< std::string, std::string > &files_to_generate); private: - void generateTable(std::stringstream &text, Table *table); - void generateHeader(std::stringstream &text, Table *table); - void generateInsert(std::stringstream &text, Table *table); - void generateUpdateFromPK(std::stringstream &text, Table *table); - void generateDeleteFromPK(std::stringstream &text, Table *table); - void generateSelectFromPK(std::stringstream &text, Table *table); - void generateSelectFromUKs(std::stringstream &text, Table *table); + std::string generateCompleteTableCode(Table &table); + + void generateHeader(std::stringstream &text, Table &table); + void generateInsert(std::stringstream &text, Table &table); + void generateUpdateFromPK(std::stringstream &text, Table &table); + void generateDeleteFromPK(std::stringstream &text, Table &table); + void generateSelectFromPK(std::stringstream &text, Table &table); + void generateSelectFromUKs(std::stringstream &text, Table &table); void generateSelectFromConstraintColumns(std::stringstream &text, std::string &table_name, std::vector< Column * > &table_columns, std::vector< Column * > &constr_columns); std::string getDAONameFromTableName(std::string &table_name); - std::vector< Column * > getTableColumns(Table *table); - std::vector< Column * > getTablePrimaryKeyColumns(Table *table); - std::vector< Column * > getTablePrimaryKeyAutoColumns(Table *table); - std::vector< std::vector< Column * > > getTableUniqueKeyColumns(Table *table); + std::vector< Column * > getTableColumns(Table &table); + std::vector< Column * > getTablePrimaryKeyColumns(Table &table); + std::vector< Column * > getTablePrimaryKeyAutoColumns(Table &table); + std::vector< std::vector< Column * > > getTableUniqueKeyColumns(Table &table); std::string getKeyNamesFromColumns(std::vector< Column * > &pk_columns); }; From 519fb06cd8e0c3e0ee2483311d96a4cd30e4da43 Mon Sep 17 00:00:00 2001 From: campisano Date: Mon, 28 Sep 2015 16:14:56 -0300 Subject: [PATCH 08/11] PythonDAOsGenerator: updated code generation to specify table schema explicitly. --- .../src/python_daos_generator.cpp | 64 ++++++++++++------- .../src/python_daos_generator.h | 4 +- 2 files changed, 43 insertions(+), 25 deletions(-) diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp index a49ed5ef34..cabe20ec80 100644 --- a/plugins/code_generator/src/python_daos_generator.cpp +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -11,14 +11,18 @@ void PythonDAOsGenerator::generateCode(DatabaseModel &model, BaseLogger &logger, std::string table_name; std::string table_code; + std::stringstream text; + for(it = tables->begin(); it != tables->end(); ++it) { schema_name = (*it)->getSchema()->getName().toUtf8().constData(); table_name = (*it)->getName().toUtf8().constData(); table_code = this->generateCompleteTableCode(*(Table *)(* it)); files_to_generate[schema_name + "_" + table_name + ".py"] = table_code; - logger.log(table_code); + text << table_code; } + + logger.log(text.str()); } // Starting code generation @@ -52,18 +56,22 @@ std::string PythonDAOsGenerator::generateCompleteTableCode(Table &table) void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table &table) { + // schema and table name + std::string schema_name = table.getSchema()->getName().toUtf8().constData(); std::string table_name = table.getName().toUtf8().constData(); - std::string dao_name = this->getDAONameFromTableName(table_name); + + // DAO class name + std::string dao_class_name = this->getDAONameFromSchemaTableName(schema_name, table_name); text << "#!/usr/bin/env python"; text << "\n# -*- coding: utf-8 -*-"; text << "\n\"\"\""; - text << "\n@package " << dao_name << " Data Access Object"; - text << "\n for '" << table_name << "' table"; + text << "\n@package " << dao_class_name << " Data Access Object"; + text << "\n for '" << schema_name << '.' << table_name << "' table"; text << "\n\"\"\""; text << '\n'; text << '\n'; - text << "\nclass " << dao_name << "():"; + text << "\nclass " << dao_class_name << "():"; text << '\n'; text << "\n def __init__(self, database):"; text << "\n self.db = database"; @@ -71,8 +79,10 @@ void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table &table) void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table) { - // table name + // schema and table name + std::string schema_name = table.getSchema()->getName().toUtf8().constData(); std::string table_name = table.getName().toUtf8().constData(); + std::string schema_table_name = schema_name + '.' + table_name; // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); @@ -119,7 +129,7 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table) text << "\n ):"; // commentary - text << "\n \"\"\" Insert a '" << table_name << "' record"; + text << "\n \"\"\" Insert a '" << schema_table_name << "' record"; text << "\n and get back the DB generated ID \"\"\""; text << '\n'; @@ -152,7 +162,7 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table) // sql query text << "\n sql = ("; - text << "\n \"INSERT INTO " << table_name << " ("; + text << "\n \"INSERT INTO " << schema_table_name << " ("; is_first_column_writed = false; for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { @@ -230,8 +240,10 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table) void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table &table) { - // table name + // schema and table name + std::string schema_name = table.getSchema()->getName().toUtf8().constData(); std::string table_name = table.getName().toUtf8().constData(); + std::string schema_table_name = schema_name + '.' + table_name; // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); @@ -280,7 +292,7 @@ void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table &t text << "\n ):"; // commentary - text << "\n \"\"\" Update a '" << table_name << "' record"; + text << "\n \"\"\" Update a '" << schema_table_name << "' record"; text << "\n using primary key \"\"\""; text << '\n'; @@ -298,7 +310,7 @@ void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table &t // sql query text << "\n sql = ("; - text << "\n \"UPDATE " << table_name << " SET \""; + text << "\n \"UPDATE " << schema_table_name << " SET \""; for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) { column = *table_columns_it; @@ -330,8 +342,10 @@ void PythonDAOsGenerator::generateUpdateFromPK(std::stringstream &text, Table &t void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table &table) { - // table name + // schema and table name + std::string schema_name = table.getSchema()->getName().toUtf8().constData(); std::string table_name = table.getName().toUtf8().constData(); + std::string schema_table_name = schema_name + '.' + table_name; // get primary key columns and iterator std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); @@ -363,7 +377,7 @@ void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table &t text << "\n ):"; // commentary - text << "\n \"\"\" Delete a '" << table_name << "' record"; + text << "\n \"\"\" Delete a '" << schema_table_name << "' record"; text << "\n using primary key \"\"\""; text << '\n'; @@ -381,7 +395,7 @@ void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table &t // sql query text << "\n sql = ("; - text << "\n \"DELETE FROM " << table_name << " WHERE \""; + text << "\n \"DELETE FROM " << schema_table_name << " WHERE \""; for(pk_columns_it = pk_columns.begin(); pk_columns_it != pk_columns.end(); ++pk_columns_it) { column = *pk_columns_it; @@ -404,8 +418,10 @@ void PythonDAOsGenerator::generateDeleteFromPK(std::stringstream &text, Table &t void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table &table) { - // table name + // schema and table name + std::string schema_name = table.getSchema()->getName().toUtf8().constData(); std::string table_name = table.getName().toUtf8().constData(); + std::string schema_table_name = schema_name + '.' + table_name; // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); @@ -414,13 +430,15 @@ void PythonDAOsGenerator::generateSelectFromPK(std::stringstream &text, Table &t std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); // generate for pk - generateSelectFromConstraintColumns(text, table_name, table_columns, pk_columns); + generateSelectFromConstraintColumns(text, schema_table_name, table_columns, pk_columns); } void PythonDAOsGenerator::generateSelectFromUKs(std::stringstream &text, Table &table) { - // table name + // schema and table name + std::string schema_name = table.getSchema()->getName().toUtf8().constData(); std::string table_name = table.getName().toUtf8().constData(); + std::string schema_table_name = schema_name + '.' + table_name; // get table columns and iterator to loop under all table columns std::vector< Column * > table_columns = this->getTableColumns(table); @@ -432,11 +450,11 @@ void PythonDAOsGenerator::generateSelectFromUKs(std::stringstream &text, Table & // generate for all uk for(uk_keys_it = uk_keys.begin(); uk_keys_it != uk_keys.end(); ++uk_keys_it) { - generateSelectFromConstraintColumns(text, table_name, table_columns, *uk_keys_it); + generateSelectFromConstraintColumns(text, schema_table_name, table_columns, *uk_keys_it); } } -void PythonDAOsGenerator::generateSelectFromConstraintColumns(std::stringstream &text, std::string &table_name, std::vector< Column * > &table_columns, std::vector< Column * > &constr_columns) +void PythonDAOsGenerator::generateSelectFromConstraintColumns(std::stringstream &text, std::string &schema_table_name, std::vector< Column * > &table_columns, std::vector< Column * > &constr_columns) { if(constr_columns.empty()) { @@ -465,7 +483,7 @@ void PythonDAOsGenerator::generateSelectFromConstraintColumns(std::stringstream text << "\n ):"; // commentary - text << "\n \"\"\" Retreive a '" << table_name << "' record"; + text << "\n \"\"\" Retreive a '" << schema_table_name << "' record"; text << "\n using primary or unique key \"\"\""; text << '\n'; @@ -492,7 +510,7 @@ void PythonDAOsGenerator::generateSelectFromConstraintColumns(std::stringstream if(std::next(table_columns_it, 1) != table_columns.end()) text << ", "; text << '\"'; } - text << "\n \" FROM " << table_name << " WHERE \""; + text << "\n \" FROM " << schema_table_name << " WHERE \""; for(constr_columns_it = constr_columns.begin(); constr_columns_it != constr_columns.end(); ++constr_columns_it) { column = *constr_columns_it; @@ -522,9 +540,9 @@ void PythonDAOsGenerator::generateSelectFromConstraintColumns(std::stringstream text << "\n raise"; } -std::string PythonDAOsGenerator::getDAONameFromTableName(std::string &table_name) +std::string PythonDAOsGenerator::getDAONameFromSchemaTableName(std::string &schema_name, std::string &table_name) { - stringstream in(table_name); + stringstream in(schema_name + '_' + table_name); stringstream out; while(!in.eof()) diff --git a/plugins/code_generator/src/python_daos_generator.h b/plugins/code_generator/src/python_daos_generator.h index b97e177b7c..d2feee765e 100644 --- a/plugins/code_generator/src/python_daos_generator.h +++ b/plugins/code_generator/src/python_daos_generator.h @@ -21,8 +21,8 @@ class PythonDAOsGenerator: public BaseCodeGenerator { void generateSelectFromPK(std::stringstream &text, Table &table); void generateSelectFromUKs(std::stringstream &text, Table &table); - void generateSelectFromConstraintColumns(std::stringstream &text, std::string &table_name, std::vector< Column * > &table_columns, std::vector< Column * > &constr_columns); - std::string getDAONameFromTableName(std::string &table_name); + void generateSelectFromConstraintColumns(std::stringstream &text, std::string &schema_table_name, std::vector< Column * > &table_columns, std::vector< Column * > &constr_columns); + std::string getDAONameFromSchemaTableName(std::string &schema_name, std::string &table_name); std::vector< Column * > getTableColumns(Table &table); std::vector< Column * > getTablePrimaryKeyColumns(Table &table); std::vector< Column * > getTablePrimaryKeyAutoColumns(Table &table); From 9ead72ef90cf910891091022bdac60c8cbfdd4fb Mon Sep 17 00:00:00 2001 From: campisano Date: Mon, 19 Oct 2015 16:55:03 -0200 Subject: [PATCH 09/11] Added 'insertAll' function to generate insert for all columns in the table. --- .../src/python_daos_generator.cpp | 37 ++++++++++++++++--- .../src/python_daos_generator.h | 4 +- 2 files changed, 35 insertions(+), 6 deletions(-) diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp index cabe20ec80..4e416a7bda 100644 --- a/plugins/code_generator/src/python_daos_generator.cpp +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -34,7 +34,8 @@ std::string PythonDAOsGenerator::generateCompleteTableCode(Table &table) this->generateHeader(text, table); // Insert - this->generateInsert(text, table); + this->generateInsertAutoPK(text, table); + this->generateInsertAll(text, table); // Update this->generateUpdateFromPK(text, table); @@ -77,7 +78,17 @@ void PythonDAOsGenerator::generateHeader(std::stringstream &text, Table &table) text << "\n self.db = database"; } -void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table) +void PythonDAOsGenerator::generateInsertAutoPK(std::stringstream &text, Table &table) +{ + this->generateInsert(text, table, false); +} + +void PythonDAOsGenerator::generateInsertAll(std::stringstream &text, Table &table) +{ + this->generateInsert(text, table, true); +} + +void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table, bool all) { // schema and table name std::string schema_name = table.getSchema()->getName().toUtf8().constData(); @@ -92,10 +103,26 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table) std::vector< Column * > pk_columns = this->getTablePrimaryKeyColumns(table); std::vector< Column * >::iterator pk_columns_it; - // get primary key columns that have a sequence - std::vector< Column * > pk_auto_columns = this->getTablePrimaryKeyAutoColumns(table); + std::string method_name = "insert"; + std::vector< Column * > pk_auto_columns; std::vector< Column * >::iterator pk_auto_columns_it; + if(all) + { + method_name += "All"; + } + else + { + // get primary key columns that have a sequence + pk_auto_columns = this->getTablePrimaryKeyAutoColumns(table); + } + + // in the case that there are no columns to insert + if(table_columns.size() - pk_auto_columns.size() <= 0) + { + return; + } + // auxiliary vars Column *column; std::string col_name; @@ -104,7 +131,7 @@ void PythonDAOsGenerator::generateInsert(std::stringstream &text, Table &table) // funcion definition and parameters text << '\n'; - text << "\n def insert("; + text << "\n def " << method_name << "("; text << "\n self"; is_first_column_writed = true; // already write self above for(table_columns_it = table_columns.begin(); table_columns_it != table_columns.end(); ++table_columns_it) diff --git a/plugins/code_generator/src/python_daos_generator.h b/plugins/code_generator/src/python_daos_generator.h index d2feee765e..2a3d36728b 100644 --- a/plugins/code_generator/src/python_daos_generator.h +++ b/plugins/code_generator/src/python_daos_generator.h @@ -15,12 +15,14 @@ class PythonDAOsGenerator: public BaseCodeGenerator { std::string generateCompleteTableCode(Table &table); void generateHeader(std::stringstream &text, Table &table); - void generateInsert(std::stringstream &text, Table &table); + void generateInsertAutoPK(std::stringstream &text, Table &table); + void generateInsertAll(std::stringstream &text, Table &table); void generateUpdateFromPK(std::stringstream &text, Table &table); void generateDeleteFromPK(std::stringstream &text, Table &table); void generateSelectFromPK(std::stringstream &text, Table &table); void generateSelectFromUKs(std::stringstream &text, Table &table); + void generateInsert(std::stringstream &text, Table &table, bool all); void generateSelectFromConstraintColumns(std::stringstream &text, std::string &schema_table_name, std::vector< Column * > &table_columns, std::vector< Column * > &constr_columns); std::string getDAONameFromSchemaTableName(std::string &schema_name, std::string &table_name); std::vector< Column * > getTableColumns(Table &table); From 631b7a1e31b4b5d8846a4009912ab7a907897506 Mon Sep 17 00:00:00 2001 From: Riccardo Campisano Date: Tue, 10 Jan 2017 15:31:45 -0200 Subject: [PATCH 10/11] Update README --- plugins/code_generator/README | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/plugins/code_generator/README b/plugins/code_generator/README index c9b2cd4f39..0c37bdf0de 100644 --- a/plugins/code_generator/README +++ b/plugins/code_generator/README @@ -8,24 +8,29 @@ # Example of pgmodeler compilation (under debian): # from http://www.campisano.org/wiki/en/Postgresql#Pgmodeler : ### -# sudo apt-get install g++ pkg-config qt5-qmake qt5-default qtchooser libpq-dev libxml2-dev +# sudo su - +# apt-get install g++ pkg-config qt5-qmake qt5-default qtchooser libpq-dev libxml2-dev +# exit +# # cd $HOME -# wget https://github.com/pgmodeler/pgmodeler/archive/v0.8.1.tar.gz -# tar -xzvf v0.8.1.tar.gz -# cd pgmodeler-0.8.1/ -# qmake PREFIX=$HOME/pgmodeler pgmodeler.pro +# git clone https://github.com/campisano/pgmodeler +# cd $HOME/pgmodeler/ +# qmake PREFIX=$HOME/pgmodeler_dev pgmodeler.pro # make # make install -# $HOME/pgmodeler/bin/pgmodeler -# +# $HOME/pgmodeler_dev/bin/pgmodeler # to run +# ### # Example of plugin compilation ### -# sudo apt-get install qttools5-dev -# cd $HOME/pgmodeler-0.8.1/plugins -# qmake PREFIX=$HOME/pgmodeler plugins.pro +# sudo su - +# apt-get install qttools5-dev +# exit +# cd $HOME/pgmodeler/plugins +# qmake PREFIX=$HOME/pgmodeler_dev plugins.pro # make # make install -# $HOME/pgmodeler/bin/pgmodeler -# # open or generate a model and press CTRL+ALT+G -# +# cd $HOME +# rm -rf pgmodeler +# $HOME/pgmodeler_dev/bin/pgmodeler +# # open a model and press CTRL+ALT+G to generate the code From caa257298f221b7a4cbfe089e1792bb6fbaae726 Mon Sep 17 00:00:00 2001 From: campisano Date: Tue, 10 Jan 2017 16:13:41 -0200 Subject: [PATCH 11/11] Minor fix related to specific database connection class --- plugins/code_generator/src/python_daos_generator.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/plugins/code_generator/src/python_daos_generator.cpp b/plugins/code_generator/src/python_daos_generator.cpp index 4e416a7bda..9e64ecd054 100644 --- a/plugins/code_generator/src/python_daos_generator.cpp +++ b/plugins/code_generator/src/python_daos_generator.cpp @@ -550,7 +550,7 @@ void PythonDAOsGenerator::generateSelectFromConstraintColumns(std::stringstream text << '\n'; // execution text << "\n try:"; - text << "\n results = self.db.execute(sql, args)"; + text << "\n results = self.db.connection.execute(sql, args)"; text << "\n if results.rowcount > 1:"; text << "\n raise RuntimeError("; text << "\n \"ERROR: Select by primary/unique key\"";