public String generate(Object argument) {
    final StringBuffer stringBuffer = new StringBuffer();
    stringBuffer.append(TEXT_1);

    CodeGeneratorArgument codeGenArgument = (CodeGeneratorArgument) argument;

    INode node = (INode) codeGenArgument.getArgument();
    String cid = node.getUniqueName();
    String dbhost = ElementParameterParser.getValue(node, "__HOST__");
    String dbname = ElementParameterParser.getValue(node, "__DATABASE__");
    String dbuser = ElementParameterParser.getValue(node, "__USERNAME__");
    String dbpass = ElementParameterParser.getValue(node, "__PASSWORD__");
    boolean authentication =
        "true"
            .equalsIgnoreCase(ElementParameterParser.getValue(node, "__REQUIRED_AUTHENTICATION__"));
    if (!authentication) {
      dbuser = null;
      dbpass = null;
    }

    String passwordFieldName = "__PASSWORD__";

    stringBuffer.append(TEXT_2);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_3);
    if (!authentication) {
      // do nothing
    } else if (ElementParameterParser.canEncrypt(node, passwordFieldName)) {
      stringBuffer.append(TEXT_4);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_5);
      stringBuffer.append(ElementParameterParser.getEncryptedValue(node, passwordFieldName));
      stringBuffer.append(TEXT_6);
    } else {
      stringBuffer.append(TEXT_7);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_8);
      stringBuffer.append(ElementParameterParser.getValue(node, passwordFieldName));
      stringBuffer.append(TEXT_9);
    }

    boolean useTriggerReplicate =
        "true".equalsIgnoreCase(ElementParameterParser.getValue(node, "__USE_TRIGGER_REPLICATE__"));
    String dbport = ElementParameterParser.getValue(node, "__PORT__");
    List<Map<String, String>> replicaTargetDB =
        (List<Map<String, String>>)
            ElementParameterParser.getObjectValue(node, "__REPLICATE_TARGET_DB__");
    boolean useExistingConn =
        "true"
            .equalsIgnoreCase(ElementParameterParser.getValue(node, "__USE_EXISTING_CONNECTION__"));
    String connection = ElementParameterParser.getValue(node, "__CONNECTION__");

    boolean isLog4jEnabled =
        ("true").equals(ElementParameterParser.getValue(node.getProcess(), "__LOG4J_ACTIVATE__"));

    stringBuffer.append(TEXT_10);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_11);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_12);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_13);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_14);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_15);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_16);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_17);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_18);

    if (useExistingConn) {
      INode connectionNode = NodeUtil.getNodeByUniqueName(node.getProcess(), connection);
      dbname = ElementParameterParser.getValue(connectionNode, "__DATABASE__");

      stringBuffer.append(TEXT_19);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_20);
      stringBuffer.append(connection);
      stringBuffer.append(TEXT_21);

      if (isLog4jEnabled) {

        stringBuffer.append(TEXT_22);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_23);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_24);
        stringBuffer.append(connection);
        stringBuffer.append(TEXT_25);
      }
    } else {

      stringBuffer.append(TEXT_26);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_27);
      stringBuffer.append(dbname);
      stringBuffer.append(TEXT_28);
      stringBuffer.append(dbhost);
      stringBuffer.append(TEXT_29);
      stringBuffer.append(dbport);
      stringBuffer.append(TEXT_30);
      stringBuffer.append(dbuser);
      stringBuffer.append(TEXT_31);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_32);

      if (useTriggerReplicate) {

        stringBuffer.append(TEXT_33);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_34);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_35);

        int index = 0;
        for (Map<String, String> targetDB : replicaTargetDB) {
          String targetDBName = targetDB.get("TARGET_DB_NAME");
          boolean isCreateTargetDB = "true".equalsIgnoreCase(targetDB.get("CREATE_TARGET"));
          boolean isContinuous = "true".equalsIgnoreCase(targetDB.get("CONTINUOUS"));
          boolean isCancel = "true".equalsIgnoreCase(targetDB.get("CANCEL_REPLICATE"));

          stringBuffer.append(TEXT_36);
          stringBuffer.append(cid);
          stringBuffer.append(TEXT_37);
          stringBuffer.append(cid);
          stringBuffer.append(TEXT_38);
          stringBuffer.append(dbname);
          stringBuffer.append(TEXT_39);
          stringBuffer.append(targetDBName);
          stringBuffer.append(TEXT_40);
          stringBuffer.append(isCreateTargetDB);
          stringBuffer.append(TEXT_41);
          stringBuffer.append(isContinuous);
          stringBuffer.append(TEXT_42);

          if (isContinuous && isCancel) {

            stringBuffer.append(TEXT_43);
            stringBuffer.append(cid);
            stringBuffer.append(TEXT_44);
            stringBuffer.append(cid);
            stringBuffer.append(TEXT_45);
            stringBuffer.append(index);
            stringBuffer.append(TEXT_46);
            stringBuffer.append(cid);
            stringBuffer.append(TEXT_47);
            stringBuffer.append(dbname);
            stringBuffer.append(TEXT_48);
            stringBuffer.append(targetDBName);
            stringBuffer.append(TEXT_49);
            stringBuffer.append(isCreateTargetDB);
            stringBuffer.append(TEXT_50);
            stringBuffer.append(isContinuous);
            stringBuffer.append(TEXT_51);
            stringBuffer.append(isCancel);
            stringBuffer.append(TEXT_52);
            stringBuffer.append(cid);
            stringBuffer.append(TEXT_53);
            stringBuffer.append(cid);
            stringBuffer.append(TEXT_54);
            stringBuffer.append(index);
            stringBuffer.append(TEXT_55);

            index++;
          }
        }
      }
    }
    if (isLog4jEnabled) {

      stringBuffer.append(TEXT_56);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_57);
      stringBuffer.append(dbname);
      stringBuffer.append(TEXT_58);
    }

    return stringBuffer.toString();
  }
  public String generate(Object argument) {
    final StringBuffer stringBuffer = new StringBuffer();
    stringBuffer.append(TEXT_1);
    stringBuffer.append(TEXT_2);

    class BasicLogUtil {
      protected String cid = "";
      protected org.talend.core.model.process.INode node = null;
      protected boolean log4jEnabled = false;
      private String logID = "";

      private BasicLogUtil() {}

      public BasicLogUtil(org.talend.core.model.process.INode node) {
        this.node = node;
        String cidx = this.node.getUniqueName();
        if (cidx.matches("^.*?tAmazonAuroraOutput_\\d+_out$")) {
          cidx = cidx.substring(0, cidx.length() - 4); // 4 ==> "_out".length();
        }
        this.cid = cidx;
        this.log4jEnabled =
            ("true")
                .equals(
                    org.talend.core.model.process.ElementParameterParser.getValue(
                        this.node.getProcess(), "__LOG4J_ACTIVATE__"));
        this.log4jEnabled =
            this.log4jEnabled
                && this.node.getComponent().isLog4JEnabled()
                && !"JOBLET".equals(node.getComponent().getComponentType().toString());
        this.logID = this.cid;
      }

      public String var(String varName) {
        return varName + "_" + this.cid;
      }

      public String str(String content) {
        return "\"" + content + "\"";
      }

      public void info(String... message) {
        log4j("info", message);
      }

      public void debug(String... message) {
        log4j("debug", message);
      }

      public void warn(String... message) {
        log4j("warn", message);
      }

      public void error(String... message) {
        log4j("error", message);
      }

      public void fatal(String... message) {
        log4j("fatal", message);
      }

      public void trace(String... message) {
        log4j("trace", message);
      }

      java.util.List<String> checkableList =
          java.util.Arrays.asList(new String[] {"info", "debug", "trace"});

      public void log4j(String level, String... messages) {
        if (this.log4jEnabled) {
          if (checkableList.contains(level)) {

            stringBuffer.append(TEXT_3);
            stringBuffer.append(level.substring(0, 1).toUpperCase() + level.substring(1));
            stringBuffer.append(TEXT_4);
          }

          stringBuffer.append(TEXT_5);
          stringBuffer.append(level);
          stringBuffer.append(TEXT_6);
          stringBuffer.append(logID);
          stringBuffer.append(TEXT_7);
          for (String message : messages) {
            stringBuffer.append(TEXT_8);
            stringBuffer.append(message);
            stringBuffer.append(TEXT_9);
          }
          stringBuffer.append(TEXT_10);
        }
      }

      public boolean isActive() {
        return this.log4jEnabled;
      }
    }

    class LogUtil extends BasicLogUtil {

      private LogUtil() {}

      public LogUtil(org.talend.core.model.process.INode node) {
        super(node);
      }

      public void startWork() {
        info(str("Start to work."));
      }

      public void endWork() {
        info(str("Done."));
      }

      public void logIgnoredException(String exception) {
        warn(exception);
      }

      public void logPrintedException(String exception) {
        error(exception);
      }

      public void logException(String exception) {
        fatal(exception);
      }

      public void logCompSetting() {
        if (log4jEnabled) {

          stringBuffer.append(TEXT_11);
          stringBuffer.append(var("log4jParamters"));
          stringBuffer.append(TEXT_12);
          stringBuffer.append(TEXT_13);
          stringBuffer.append(var("log4jParamters"));
          stringBuffer.append(TEXT_14);

          java.util.Set<org.talend.core.model.process.EParameterFieldType> ignoredParamsTypes =
              new java.util.HashSet<org.talend.core.model.process.EParameterFieldType>();
          ignoredParamsTypes.addAll(
              java.util.Arrays.asList(
                  org.talend.core.model.process.EParameterFieldType.SCHEMA_TYPE,
                  org.talend.core.model.process.EParameterFieldType.LABEL,
                  org.talend.core.model.process.EParameterFieldType.EXTERNAL,
                  org.talend.core.model.process.EParameterFieldType.MAPPING_TYPE,
                  org.talend.core.model.process.EParameterFieldType.IMAGE,
                  org.talend.core.model.process.EParameterFieldType.TNS_EDITOR,
                  org.talend.core.model.process.EParameterFieldType.WSDL2JAVA,
                  org.talend.core.model.process.EParameterFieldType.GENERATEGRAMMARCONTROLLER,
                  org.talend.core.model.process.EParameterFieldType
                      .GENERATE_SURVIVORSHIP_RULES_CONTROLLER,
                  org.talend.core.model.process.EParameterFieldType.REFRESH_REPORTS,
                  org.talend.core.model.process.EParameterFieldType.BROWSE_REPORTS,
                  org.talend.core.model.process.EParameterFieldType.PALO_DIM_SELECTION,
                  org.talend.core.model.process.EParameterFieldType.GUESS_SCHEMA,
                  org.talend.core.model.process.EParameterFieldType.MATCH_RULE_IMEX_CONTROLLER,
                  org.talend.core.model.process.EParameterFieldType.MEMO_PERL,
                  org.talend.core.model.process.EParameterFieldType.DBTYPE_LIST,
                  org.talend.core.model.process.EParameterFieldType.VERSION,
                  org.talend.core.model.process.EParameterFieldType.TECHNICAL,
                  org.talend.core.model.process.EParameterFieldType.ICON_SELECTION,
                  org.talend.core.model.process.EParameterFieldType.JAVA_COMMAND,
                  org.talend.core.model.process.EParameterFieldType.TREE_TABLE,
                  org.talend.core.model.process.EParameterFieldType.VALIDATION_RULE_TYPE,
                  org.talend.core.model.process.EParameterFieldType.DCSCHEMA,
                  org.talend.core.model.process.EParameterFieldType.SURVIVOR_RELATION,
                  org.talend.core.model.process.EParameterFieldType.REST_RESPONSE_SCHEMA_TYPE));
          for (org.talend.core.model.process.IElementParameter ep :
              org.talend.core.model.utils.NodeUtil.getDisplayedParameters(node)) {
            if (!ep.isLog4JEnabled() || ignoredParamsTypes.contains(ep.getFieldType())) {
              continue;
            }
            String name = ep.getName();
            if (org.talend.core.model.process.EParameterFieldType.PASSWORD.equals(
                ep.getFieldType())) {
              String epName = "__" + name + "__";
              String password = "";
              if (org.talend.core.model.process.ElementParameterParser.canEncrypt(node, epName)) {
                password =
                    org.talend.core.model.process.ElementParameterParser.getEncryptedValue(
                        node, epName);
              } else {
                String passwordValue =
                    org.talend.core.model.process.ElementParameterParser.getValue(node, epName);
                if (passwordValue == null
                    || "".equals(passwordValue.trim())) { // for the value which empty
                  passwordValue = "\"\"";
                }
                password =
                    "******" + passwordValue + ")";
              }

              stringBuffer.append(TEXT_15);
              stringBuffer.append(var("log4jParamters"));
              stringBuffer.append(TEXT_16);
              stringBuffer.append(name);
              stringBuffer.append(TEXT_17);
              stringBuffer.append(password);
              stringBuffer.append(TEXT_18);

            } else {
              String value =
                  org.talend.core.model.utils.NodeUtil.getNormalizeParameterValue(node, ep);

              stringBuffer.append(TEXT_19);
              stringBuffer.append(var("log4jParamters"));
              stringBuffer.append(TEXT_20);
              stringBuffer.append(name);
              stringBuffer.append(TEXT_21);
              stringBuffer.append(value);
              stringBuffer.append(TEXT_22);
            }

            stringBuffer.append(TEXT_23);
            stringBuffer.append(var("log4jParamters"));
            stringBuffer.append(TEXT_24);
          }
        }
        debug(var("log4jParamters"));
      }

      // no use for now, because we log the data by rowStruct
      public void traceData(
          String rowStruct,
          java.util.List<org.talend.core.model.metadata.IMetadataColumn> columnList,
          String nbline) {
        if (log4jEnabled) {

          stringBuffer.append(TEXT_25);
          stringBuffer.append(var("log4jSb"));
          stringBuffer.append(TEXT_26);

          for (org.talend.core.model.metadata.IMetadataColumn column : columnList) {
            org.talend.core.model.metadata.types.JavaType javaType =
                org.talend.core.model.metadata.types.JavaTypesManager.getJavaTypeFromId(
                    column.getTalendType());
            String columnName = column.getLabel();
            boolean isPrimit =
                org.talend.core.model.metadata.types.JavaTypesManager.isJavaPrimitiveType(
                    column.getTalendType(), column.isNullable());
            if (isPrimit) {

              stringBuffer.append(TEXT_27);
              stringBuffer.append(var("log4jSb"));
              stringBuffer.append(TEXT_28);
              stringBuffer.append(rowStruct);
              stringBuffer.append(TEXT_29);
              stringBuffer.append(columnName);
              stringBuffer.append(TEXT_30);

            } else {

              stringBuffer.append(TEXT_31);
              stringBuffer.append(rowStruct);
              stringBuffer.append(TEXT_32);
              stringBuffer.append(columnName);
              stringBuffer.append(TEXT_33);
              stringBuffer.append(TEXT_34);
              stringBuffer.append(var("log4jSb"));
              stringBuffer.append(TEXT_35);
              stringBuffer.append(TEXT_36);
              stringBuffer.append(var("log4jSb"));
              stringBuffer.append(TEXT_37);
              stringBuffer.append(rowStruct);
              stringBuffer.append(TEXT_38);
              stringBuffer.append(columnName);
              stringBuffer.append(TEXT_39);
            }

            stringBuffer.append(TEXT_40);
            stringBuffer.append(var("log4jSb"));
            stringBuffer.append(TEXT_41);
          }
        }
        trace(str("Content of the record "), nbline, str(": "), var("log4jSb"));
      }
    }

    class LogHelper {

      java.util.Map<String, String> pastDict = null;

      public LogHelper() {
        pastDict = new java.util.HashMap<String, String>();
        pastDict.put("insert", "inserted");
        pastDict.put("update", "updated");
        pastDict.put("delete", "deleted");
        pastDict.put("upsert", "upserted");
      }

      public String upperFirstChar(String data) {
        return data.substring(0, 1).toUpperCase() + data.substring(1);
      }

      public String toPastTense(String data) {
        return pastDict.get(data);
      }
    }
    LogHelper logHelper = new LogHelper();

    LogUtil log = null;

    stringBuffer.append(TEXT_42);

    class DBConnLogUtil extends BasicLogUtil {

      private DBConnLogUtil() {}

      protected DBConnLogUtil(org.talend.core.model.process.INode node) {
        super(node);
      }

      public void logJDBCDriver(String driverClass) {
        debug(str("Driver ClassName: "), driverClass, str("."));
      }

      public void connTry(String url, String dbUser) {
        if (dbUser != null) {
          info(
              str("Connection attempts to '"),
              url,
              str("' with the username '"),
              dbUser,
              str("'."));
        } else {
          info(str("Connection attempts to '"), url, str("'."));
        }
      }

      public void connDone(String url) {
        info(str("Connection to '"), url, str("' has succeeded."));
      }

      public void useExistConn(String url, String dbUser) {
        if (dbUser != null) {
          info(
              str("Uses an existing connection with username '"),
              dbUser,
              str("'. Connection URL: "),
              url,
              str("."));
        } else {
          info(str("Uses an existing connection. Connection URL: "), url, str("."));
        }
      }

      public void closeTry(String connCompID) {
        if (connCompID == null) {
          info(str("Closing the connection to the database."));
        } else {
          info(str("Closing the connection "), connCompID, str(" to the database."));
        }
      }

      public void closeDone(String connCompID) {
        if (connCompID == null) {
          info(str("Connection to the database has closed."));
        } else {
          info(str("Connection "), connCompID, str(" to the database has closed."));
        }
      }
    }

    class DBTableActionLogUtil extends BasicLogUtil {
      private DBTableActionLogUtil() {}

      protected DBTableActionLogUtil(org.talend.core.model.process.INode node) {
        super(node);
      }

      public void dropTry(String tableName) {
        tableActionTry(tableName, str("Dropping"));
      }

      public void dropDone(String tableName) {
        tableActionDone(tableName, str("Drop"));
      }

      public void createTry(String tableName) {
        tableActionTry(tableName, str("Creating"));
      }

      public void createDone(String tableName) {
        tableActionDone(tableName, str("Create"));
      }

      public void clearTry(String tableName) {
        tableActionTry(tableName, str("Clearing"));
      }

      public void clearDone(String tableName) {
        tableActionDone(tableName, str("Clear"));
      }

      public void truncateTry(String tableName) {
        tableActionTry(tableName, str("Truncating"));
      }

      public void truncateDone(String tableName) {
        tableActionDone(tableName, str("Truncate"));
      }

      public void truncateReuseStorageTry(String tableName) {
        tableActionTry(tableName, str("Truncating reuse storage"));
      }

      public void truncateReuseStorageDone(String tableName) {
        tableActionDone(tableName, str("Truncate reuse stroage"));
      }

      private void tableActionTry(String tableName, String action) {
        info(action, str(" table '"), tableName, str("'."));
      }

      private void tableActionDone(String tableName, String action) {
        info(action, str(" table '"), tableName, str("' has succeeded."));
      }
    }

    class DBCommitLogUtil extends BasicLogUtil {
      private DBCommitLogUtil() {}

      protected DBCommitLogUtil(org.talend.core.model.process.INode node) {
        super(node);
      }

      public void logAutoCommit(String autoCommit) {
        debug(str("Connection is set auto commit to '"), autoCommit, str("'."));
      }

      public void commitTry(String connCompID, String commitCount) {
        if (commitCount == null && connCompID == null) {
          debug(str("Connection starting to commit."));
        } else if (commitCount == null) {
          debug(str("Connection "), connCompID, str(" starting to commit."));
        } else if (connCompID == null) {
          debug(str("Connection starting to commit "), commitCount, str(" record(s)."));
        } else {
          debug(
              str("Connection "),
              connCompID,
              str(" starting to commit "),
              commitCount,
              str(" record(s)."));
        }
      }

      public void commitDone(String connCompID) {
        if (connCompID == null) {
          debug(str("Connection commit has succeeded."));
        } else {
          debug(str("Connection "), connCompID, (" commit has succeeded."));
        }
      }
    }

    class DBBatchLogUtil extends BasicLogUtil {
      private DBBatchLogUtil() {}

      protected DBBatchLogUtil(org.talend.core.model.process.INode node) {
        super(node);
      }

      public void executeTry(String action) {
        debug(str("Executing the "), action, str(" batch."));
      }

      public void executeDone(String action) {
        debug(str("The "), action, str(" batch execution has succeeded."));
      }
    }

    class DBDataActionLogUtil extends BasicLogUtil {
      private DBDataActionLogUtil() {}

      protected DBDataActionLogUtil(org.talend.core.model.process.INode node) {
        super(node);
      }

      public void inserting(String nbline) {
        sqlAction(nbline, str("Inserting"));
      }

      public void deleting(String nbline) {
        sqlAction(nbline, str("Deleting"));
      }

      public void updating(String nbline) {
        sqlAction(nbline, str("Updating"));
      }

      public void replacing(String nbline) {
        sqlAction(nbline, str("Replacing"));
      }

      public void insertingOnDuplicateKeyUpdating(String nbline) {
        sqlAction(nbline, str("Inserting on duplicate key updating"));
      }

      public void insertingIgnore(String nbline) {
        sqlAction(nbline, str("Inserting ignore"));
      }

      private void sqlAction(String nbline, String action) {
        if (nbline == null) {
          debug(action, str(" the record."));
        } else {
          debug(action, str(" the record "), nbline, str("."));
        }
      }

      public void sqlExecuteTry(String sql) {
        debug(str("Executing '"), sql, str("'."));
      }

      public void sqlExecuteDone(String sql) {
        debug(str("Execute '"), sql, str("' has succeeded."));
      }

      public void addingToBatch(String nbline, String batchAction) {
        debug(str("Adding the record "), nbline, str(" to the "), batchAction, str(" batch."));
      }
    }

    class DBStateLogUtil extends BasicLogUtil {
      private DBStateLogUtil() {}

      protected DBStateLogUtil(org.talend.core.model.process.INode node) {
        super(node);
      }

      public void logInsertedLines(String nbline) {
        logFinishedLines(nbline, str("inserted"));
      }

      public void logUpdatedLines(String nbline) {
        logFinishedLines(nbline, str("updated"));
      }

      public void logDeletedLines(String nbline) {
        logFinishedLines(nbline, str("deleted"));
      }

      public void logRejectedLines(String nbline) {
        logFinishedLines(nbline, str("rejected"));
      }

      private void logFinishedLines(String nbline, String action) {
        info(str("Has "), action, str(" "), nbline, str(" record(s)."));
      }
    }
    class DBLogUtil extends LogUtil {
      DBConnLogUtil conn = null;
      DBTableActionLogUtil table = null;
      DBCommitLogUtil commit = null;
      DBBatchLogUtil batch = null;
      DBDataActionLogUtil data = null;
      DBStateLogUtil state = null;

      private DBLogUtil() {}

      protected DBLogUtil(org.talend.core.model.process.INode node) {
        super(node);
        conn = new DBConnLogUtil(node);
        table = new DBTableActionLogUtil(node);
        commit = new DBCommitLogUtil(node);
        batch = new DBBatchLogUtil(node);
        data = new DBDataActionLogUtil(node);
        state = new DBStateLogUtil(node);
      }

      public DBConnLogUtil conn() {
        return conn;
      }

      public DBTableActionLogUtil table() {
        return table;
      }

      public DBCommitLogUtil commit() {
        return commit;
      }

      public DBBatchLogUtil batch() {
        return batch;
      }

      public DBDataActionLogUtil data() {
        return data;
      }

      public DBStateLogUtil state() {
        return state;
      }
    }
    DBLogUtil dbLog = null;

    CodeGeneratorArgument codeGenArgument = (CodeGeneratorArgument) argument;
    INode node = (INode) codeGenArgument.getArgument();
    String cid = node.getUniqueName();
    dbLog = new DBLogUtil(node);

    String dbhost = ElementParameterParser.getValue(node, "__HOST__");
    String dbport = ElementParameterParser.getValue(node, "__PORT__");
    String dbname = ElementParameterParser.getValue(node, "__DBNAME__");
    String dbuser = ElementParameterParser.getValue(node, "__USER__");

    String spName = ElementParameterParser.getValue(node, "__SP_NAME__");
    boolean isFunction = ("true").equals(ElementParameterParser.getValue(node, "__IS_FUNCTION__"));
    List<Map<String, String>> spArgs =
        (List<Map<String, String>>) ElementParameterParser.getObjectValue(node, "__SP_ARGS__");

    stringBuffer.append(TEXT_43);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_44);

    String useExistingConn = ElementParameterParser.getValue(node, "__USE_EXISTING_CONNECTION__");
    if (("true").equals(useExistingConn)) {
      String connection = ElementParameterParser.getValue(node, "__CONNECTION__");
      String conn = "conn_" + connection;

      stringBuffer.append(TEXT_45);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_46);
      stringBuffer.append(conn);
      stringBuffer.append(TEXT_47);

      INode connectionNode = NodeUtil.getNodeByUniqueName(node.getProcess(), connection);
      boolean specify_alias =
          "true"
              .equals(
                  ElementParameterParser.getValue(connectionNode, "__SPECIFY_DATASOURCE_ALIAS__"));
      if (specify_alias) {
        String alias = ElementParameterParser.getValue(connectionNode, "__DATASOURCE_ALIAS__");
        String autoCommit =
            "true".equals(ElementParameterParser.getValue(connectionNode, "__AUTO_COMMIT__"))
                ? "true"
                : "false";

        stringBuffer.append(TEXT_48);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_49);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_50);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_51);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_52);
        stringBuffer.append((null != alias && !("".equals(alias))) ? alias : "\"\"");
        stringBuffer.append(TEXT_53);
      }

      dbLog
          .conn()
          .useExistConn(
              "connection_" + cid + ".getMetaData().getURL()",
              "connection_" + cid + ".getMetaData().getUserName()");

    } else {
      boolean specify_alias =
          "true".equals(ElementParameterParser.getValue(node, "__SPECIFY_DATASOURCE_ALIAS__"));
      if (specify_alias) {
        String alias = ElementParameterParser.getValue(node, "__DATASOURCE_ALIAS__");

        stringBuffer.append(TEXT_54);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_55);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_56);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_57);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_58);
        stringBuffer.append((null != alias && !("".equals(alias))) ? alias : "\"\"");
        stringBuffer.append(TEXT_59);
      }
      String dbproperties = ElementParameterParser.getValue(node, "__PROPERTIES__");
      if (dbproperties == null || ("\"\"").equals(dbproperties) || ("").equals(dbproperties)) {

        stringBuffer.append(TEXT_60);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_61);
        stringBuffer.append(dbhost);
        stringBuffer.append(TEXT_62);
        stringBuffer.append(dbport);
        stringBuffer.append(TEXT_63);
        stringBuffer.append(dbname);
        stringBuffer.append(TEXT_64);

      } else {

        stringBuffer.append(TEXT_65);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_66);
        stringBuffer.append(dbhost);
        stringBuffer.append(TEXT_67);
        stringBuffer.append(dbport);
        stringBuffer.append(TEXT_68);
        stringBuffer.append(dbname);
        stringBuffer.append(TEXT_69);
        stringBuffer.append(dbproperties);
        stringBuffer.append(TEXT_70);
      }

      stringBuffer.append(TEXT_71);
      dbLog.conn().logJDBCDriver(dbLog.str("com.ibm.db2.jcc.DB2Driver"));

      String passwordFieldName = "__PASS__";

      stringBuffer.append(TEXT_72);
      if (ElementParameterParser.canEncrypt(node, passwordFieldName)) {
        stringBuffer.append(TEXT_73);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_74);
        stringBuffer.append(ElementParameterParser.getEncryptedValue(node, passwordFieldName));
        stringBuffer.append(TEXT_75);
      } else {
        stringBuffer.append(TEXT_76);
        stringBuffer.append(cid);
        stringBuffer.append(TEXT_77);
        stringBuffer.append(ElementParameterParser.getValue(node, passwordFieldName));
        stringBuffer.append(TEXT_78);
      }
      dbLog.conn().connTry(dbLog.var("url"), dbuser);
      stringBuffer.append(TEXT_79);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_80);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_81);
      stringBuffer.append(dbuser);
      stringBuffer.append(TEXT_82);
      stringBuffer.append(cid);
      stringBuffer.append(TEXT_83);
      dbLog.conn().connDone(dbLog.var("url"));

      if (specify_alias) {

        stringBuffer.append(TEXT_84);
      }
    }
    dbLog.commit().logAutoCommit("connection_" + cid + ".getAutoCommit()");

    stringBuffer.append(TEXT_85);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_86);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_87);
    stringBuffer.append(isFunction ? "? = " : "");
    stringBuffer.append(TEXT_88);
    stringBuffer.append(spName);
    stringBuffer.append(TEXT_89);

    boolean isFirstArg = true;
    for (int i = 0; i < spArgs.size(); i++) {
      if (!("RECORDSET").equals(spArgs.get(i).get("TYPE"))) {
        if (isFirstArg) {

          stringBuffer.append(TEXT_90);

          isFirstArg = false;
        } else {

          stringBuffer.append(TEXT_91);
        }
      }
    }

    stringBuffer.append(TEXT_92);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_93);
    stringBuffer.append(cid);
    stringBuffer.append(TEXT_94);
    stringBuffer.append(TEXT_95);
    return stringBuffer.toString();
  }