6830-2.patch

new/src/com/goldencode/p2j/convert/db/ConversionData.java 2022-10-25 08:24:00 +0000
147	147	{
148	148	// check if the table exists
149	149	boolean[] found = { false };
	150	Object[] args = new Object[] {table.toUpperCase() + "__WORK"};
150	151	helper.executeQuery("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES " +
151		"WHERE TABLE_SCHEMA = SCHEMA() AND TABLE_NAME LIKE '" + table.toUpperCase() + "__WORK'", (rs) ->
	152	"WHERE TABLE_SCHEMA = SCHEMA() AND TABLE_NAME LIKE ?", (rs) ->
152	153	{
153	154	found[0] = true;
154		});
	155	}, args);
155	156
156	157	if (!found[0])
157	158	{

           sb.append(defBuffer.getTable());
           sb.append(" where ");
           sb.append(TemporaryBuffer.MULTIPLEX_FIELD_NAME);
           sb.append(" = ");
           sb.append(defBuffer.getMultiplexID());
           sb.append(" = ?");
           Object[] args = new Object[] {defBuffer.getMultiplexID()};
           try
+          {
              Object res = persistence.getSingleSQLResult(sb.toString(), null);
              Object res = persistence.getSingleSQLResult(sb.toString(), args);
              if (res != null)
+             {
                 return true;

              .append(Buffer.ORIGIN_ROWID_FIELD).append("=NULL, ")
              .append(Buffer.AFTER_ROWID_FIELD).append("=NULL")
              .append(" where ")
              .append(TemporaryBuffer.MULTIPLEX_FIELD_NAME).append(" = ").append(afterBuf.getMultiplexID());
              .append(TemporaryBuffer.MULTIPLEX_FIELD_NAME).append(" = ?");
           Object[] args = new Object[] {afterBuf.getMultiplexID()};
           try
+          {
              boolean noUndo = !beforeBuf.isUndoable();
              int cnt = persistence.executeSQL(buf.toString(), null, noUndo);
              int cnt = persistence.executeSQL(buf.toString(), args, noUndo);
              afterBuf.pruneSessionCache();
              if (log.isLoggable(Level.FINE))
+             {

new/src/com/goldencode/p2j/persist/FastCopyHelper.java 2022-10-25 08:24:56 +0000
811	811	private static void restartSequence(Persistence persistence, String sequenceName, Long start)
812	812	throws PersistenceException
813	813	{
814		persistence.executeSQL("alter sequence " + sequenceName + " restart with " + start);
	814	Object[] args = new Object[] {start};
	815	String stmt = persistence.getDialect().getSequenceSetValString(sequenceName);
	816	persistence.executeSQL(stmt, args);
815	817	}
816	818
817	819	/**

              // then update the flag for the after buffer:
              hql = new HQLExpression("update ");
              hql.append(getDMOImplementationName());
              hql.append(" set _rowState = ").append(Integer.toString(Buffer.ROW_CREATED));
              hql.append(" where ").append(MULTIPLEX_FIELD_NAME).append(" = ");
              hql.append(Integer.toString(getMultiplexID()));
              hql.append(" set _rowState = ?");
              hql.append(" where ").append(MULTIPLEX_FIELD_NAME).append(" = ?");
              hql.append(" and (_rowState is null or _rowState = 0)");
              persistence.deleteOrUpdate(hql.toFinalExpression(), null, getEntityName(), !isUndoable());
              Object[] args = new Object[] {Integer.toString(Buffer.ROW_CREATED), Integer.toString(getMultiplexID())};
              persistence.deleteOrUpdate(hql.toFinalExpression(), args, getEntityName(), !isUndoable());
+          }
           catch (PersistenceException exc)
+          {
-...
           try
+          {
              Object[] args = new Object[] {getMultiplexID()};
              String sql = "select count(*) from " + getTable() +
                           " where " + MULTIPLEX_FIELD_NAME + " = " + getMultiplexID();
              Long res = getPersistence().getSingleSQLResult(sql, null);
                           " where " + MULTIPLEX_FIELD_NAME + " = ?";
              Long res = getPersistence().getSingleSQLResult(sql, args);
              return res.intValue();
+          }
-...
+          {
              if (!full)
+             {
                 Object[] multiplexArgs = new Object[] {multiplexID};
                 // execute a simple query to determine if there is any record in this virtual table
                 String checkStmt =
                       "select tt." + Session.PK + " from " + table + " tt " +
                       "where tt." + MULTIPLEX_FIELD_NAME + " = " + multiplexID + " limit 1";
                 Long id = persistence.getSingleSQLResult(checkStmt, null);
                       "where tt." + MULTIPLEX_FIELD_NAME + " = ?" + " limit 1";
                 Long id = persistence.getSingleSQLResult(checkStmt, multiplexArgs);
                 full = (id == null);
+             }

        public abstract String getSequenceSetValString(String sequenceName, long newVal);
        /**
         * Generate the appropriate select statement to reset the value of a sequence.
+        *
         * @param   sequenceName
         *          The name of the sequence.
+        *
         * @return  Dialect-specific string to set the current value of the sequence, or {@code null}
         *          if not supported.
         */
        public abstract String getSequenceSetValString(String sequenceName);
        /**
         * Generate the appropriate select statement to reset the value of a sequence.
+        *
         * @return  Dialect-specific string to set the current value of the sequence, or {@code null}
         *          if not supported.
         */
        public abstract String getSequenceSetValString();
        /**
         * Generate the appropriate select statement to retrieve the next value of a sequence.
+        *
         * @param   sequenceName
-...
        public abstract String getSequenceCurrValString(String sequenceName);
        /**
         * Generate the appropriate select statement to retrieve the current value of a sequence.
+        *
         * @return  Dialect-specific string to query the sequence, or {@code null} if not supported.
         */
        public String getSequenceCurrValString()
+       {
           throw new IllegalStateException(
                    "Current value of a sequence cannot be retrieved using prepared statements.");
+       }
        /**
         * Returns {@code true} if this dialect fully support the sequences as 4GL language (most important:
         * bounded values, cycle). If not fully supported, additional code is needed in P2J sequence class
         * implementation to fix this.

+       }
        /**
         * Generate the appropriate select statement to reset the value of a sequence.
+        *
         * @param   sequenceName
         *          The name of the sequence.
+        *
         * @return  Dialect-specific string to set the current value of the sequence, or {@code null}
         *          if not supported.
+        *
         * @see  <a href="https://mariadb.com/kb/en/setval/">SETVAL() Function</a>
         */
        @Override
        public String getSequenceSetValString(String sequenceName)
+       {
           return "select setval(" + sequenceName + ", ?)";
+       }
        /**
         * Generate the appropriate select statement to reset the value of a sequence.
+        *
         * @return  Dialect-specific string to set the current value of the sequence, or {@code null}
         *          if not supported.
+        *
         * @see  <a href="https://mariadb.com/kb/en/setval/">SETVAL() Function</a>
         */
        @Override
        public String getSequenceSetValString()
+       {
           return "select setval(?, ?)";
+       }
        /**
         * Generate the appropriate select statement to retrieve the next value of a sequence.
+        *
         * @param   sequenceName

+       }
        /**
         * Generate the appropriate select statement to reset the value of a
         * sequence.
+        *
         * @param   sequenceName
         *          The name of the sequence.
+        *
         * @return  Dialect-specific string to query the sequence, or
         *          <code>null</code> if not supported.
         */
        @Override
        public String getSequenceSetValString(String sequenceName)
+       {
           return "alter sequence " + sequenceName + " restart with ?";
+       }
        /**
         * Generate the appropriate select statement to reset the value of a
         * sequence.
+        *
         * @return  Dialect-specific string to query the sequence, or
         *          <code>null</code> if not supported.
         */
        @Override
        public String getSequenceSetValString()
+       {
           throw new IllegalStateException("Can't reset value of a sequence with prepared statement in H2");
+       }
        /**
         * Generate the appropriate select statement to retrieve the current
         * value of a sequence.
+        *
-...
           return "select current_value from information_schema.sequences " +
                  "where upper(sequence_name) = '" + sequenceName.toUpperCase() + "'";
+       }
        /**
         * Generate the appropriate select statement to retrieve the current
         * value of a sequence.
+        *
         * @return  Dialect-specific string to query the sequence, or
         *          <code>null</code> if not supported.
         */
        @Override
        public String getSequenceCurrValString()
+       {
           // this feature is not supported by H2 directly, use a workaround
           return "select current_value from information_schema.sequences " +
                  "where upper(sequence_name) = ?";
+       }
        /**
         * Returns <code>true</code> if this dialect fully support the sequences as

        /**
         * Generate the appropriate select statement to retrieve the next value of a sequence.
+        *
         * @param   sequenceName
         *          The name of the sequence.
+        *
         * @return  Dialect-specific string to query the sequence, or
         *          <code>null</code> if not supported.
         */
        @Override
        public String getSequenceSetValString(String sequenceName)
+       {
           return "select setval('" + sequenceName + "', ?)";
+       }
        /**
         * Generate the appropriate select statement to retrieve the next value of a sequence.
+        *
         * @return  Dialect-specific string to query the sequence, or
         *          <code>null</code> if not supported.
         */
        @Override
        public String getSequenceSetValString()
+       {
           return "select setval(?, ?)";
+       }
        /**
         * Generate the appropriate select statement to retrieve the next value of a sequence.
+        *
         * @param   sequenceName
         *          The name of the sequence to be queried.

+       }
        /**
         * Generate the appropriate select statement to reset the value of a sequence.
+        *
         * @param   sequenceName
         *          The name of the sequence.
+        *
         * @return  Returning {@code null} since this dialect does not support sequences.
         */
        @Override
        public String getSequenceSetValString(String sequenceName)
+       {
           return null;
+       }
        /**
         * Generate the appropriate select statement to reset the value of a sequence.
+        *
         * @return  Returning {@code null} since this dialect does not support sequences.
         */
        @Override
        public String getSequenceSetValString()
+       {
           return null;
+       }
        /**
         * Generate the appropriate select statement to retrieve the next value of a sequence.
+        *
         * @param   sequenceName

+       }
        /**
         * Generate the appropriate select statement to retrieve the current value of a sequence.
+        *
         * @return  Dialect-specific string to query the sequence.
         */
        @Override
        public String getSequenceCurrValString()
+       {
           // the cast is needed because the column is of 'variant' datatype.
           // the sql driver does not handle it and reports the following error:
           // 08S01 The "variant" data type is not supported.
           return "select cast(current_value as bigint) " +
                  "from sys.sequences where name = ?";
+       }
        /**
         * Generate the appropriate select statement to retrieve the next value of a sequence.
+        *
         * @param   sequenceName

+                }
                 String hql = "delete from " + entity +
                              " where " + DatabaseManager.PRIMARY_KEY + " = " + id;
                              " where " + DatabaseManager.PRIMARY_KEY + " = ?";
                 Session session = null;
                 boolean inTx = false;
-...
+                {
                    session = new Session(dirtyDatabase);
                    inTx = session.beginTransaction();
                    Query query = Session.createQuery(hql);
                    query.setParameter(0, id);
                    query.executeUpdate(session);
                    session.commit();
+                }
                 catch (PersistenceException exc)

              // drop all records that are no more valid
              StringBuilder buf = new StringBuilder(
                    "delete from " + TRANS_TABLE + " where not trans_num in (");
              List<Object> args = new ArrayList<>();
              Iterator<Integer> it = transactions.values().iterator();
              for (int i = 0; it.hasNext(); i++)
+             {
-...
                    buf.append(',');
+                }
                 buf.append(it.next());
                 args.add(it.next());
                 buf.append('?');
+             }
              buf.append(')');
              int delCounter = p.executeSQL(buf.toString());
              int delCounter = p.executeSQL(buf.toString(), args.toArray());
              if (LOG.isLoggable(Level.FINE))
+             {
                 LOG.log(Level.FINE, "Dropped " + delCounter + " old _trans records from " + dbName);

new/src/com/goldencode/p2j/persist/sequence/H2SequenceHandler.java 2022-10-25 08:27:18 +0000
140	140
141	141	Persistence persistence = ConnectionManager.getPersistence(ldbName);
142	142	Dialect dialect = persistence.getDialect();
143		String strQuery = dialect.getSequenceCurrValString(seqName);
	143	Object[] args = new Object[] {seqName};
	144	String strQuery = dialect.getSequenceCurrValString();
144	145	int64 ret;
145	146
146	147	try
147	148	{
148		ret = getResultValue(persistence.getSingleSQLResult(strQuery, null));
	149	ret = getResultValue(persistence.getSingleSQLResult(strQuery, args));
149	150	}
150	151	catch (PersistenceException pe)
151	152	{
...	...
365	366
366	367	Persistence persistence = ConnectionManager.getPersistence(ldbName);
367	368	Dialect dialect = persistence.getDialect();
368		String strQuery = dialect.getSequenceSetValString(seqName, newValFixed);
	369	Object[] args = new Object[] {newValFixed};
	370	String strQuery = dialect.getSequenceSetValString(seqName);
369	371
370	372	try
371	373	{
372		persistence.executeSQL(strQuery);
	374	persistence.executeSQL(strQuery, args);
373	375	}
374	376	catch (PersistenceException pe)
375	377	{

new/src/com/goldencode/p2j/persist/sequence/MariaDbSequenceHandler.java 2022-10-26 07:26:33 +0000
270	270
271	271	Persistence persistence = ConnectionManager.getPersistence(ldbName);
272	272	Dialect dialect = persistence.getDialect();
273		String setCrtValQuery = dialect.getSequenceSetValString(seqName, newVal);
	273	Object[] args = new Object[] {seqName, newVal};
	274	String setCrtValQuery = dialect.getSequenceSetValString();
274	275
275	276	try
276	277	{
277		persistence.getSingleSQLResult(setCrtValQuery, null);
	278	persistence.getSingleSQLResult(setCrtValQuery, args);
278	279	}
279	280	catch (PersistenceException pe)
280	281	{

new/src/com/goldencode/p2j/persist/sequence/PostgreSQLSequenceHandler.java 2022-10-26 07:26:46 +0000
281	281
282	282	Persistence persistence = ConnectionManager.getPersistence(ldbName);
283	283	Dialect dialect = persistence.getDialect();
284		String setCrtValQuery = dialect.getSequenceSetValString(seqName, newVal);
	284	Object[] args = new Object[] {seqName, newVal};
	285	String setCrtValQuery = dialect.getSequenceSetValString();
285	286
286	287	try
287	288	{
288		persistence.getSingleSQLResult(setCrtValQuery, null);
	289	persistence.getSingleSQLResult(setCrtValQuery, args);
289	290	}
290	291	catch (PersistenceException pe)
291	292	{

              // read back the id that was autogenerated
              ResultSet rs = stmtReportInsert.getGeneratedKeys();
              PreparedStatement stmt = null;
              rs.next();
              rpt.id = rs.getLong(1);
              List<Object> args = new ArrayList<>();
              if (processTags && rpt.tags != null && !rpt.tags.isEmpty())
+             {
                 StringBuilder buf = new StringBuilder("select id, name from tag where name in('");
                 StringBuilder buf = new StringBuilder("select id, name from tag where name in(");
                 Iterator<String> iter = rpt.tags.iterator();
                 for (int i = 0; iter.hasNext(); i++)
+                {
                    if (i > 0)
+                   {
                       buf.append("', '");
                       buf.append(", ");
+                   }
                    String tag = iter.next();
                    tag.replaceAll("\'", "\\\'");
                    buf.append(tag);
                    buf.append("?");
                    args.add(tag);
+                }
                 buf.append("')");
                 buf.append(")");
                 String sql = buf.toString();
                 Map<String, Long> tagMap = new HashMap<>();
                 Statement stmt = connection.createStatement();
                 rs = stmt.executeQuery(sql);
                 stmt = connection.prepareStatement(sql);
                 for (int i = 0; i < args.size(); i++)
+                {
                    stmt.setObject(i + 1, args.get(i));
+                }
                 rs = stmt.executeQuery();
                 while (rs.next())
+                {
                    long tid = rs.getLong(1);
-...
                    stmtRptTagInsert.clearParameters();
+                }
+             }
              if (rs != null && !rs.isClosed())
+             {
                 rs.close();
+             }
              if (stmt != null && !stmt.isClosed())
+             {
                 stmt.close();
+             }
+          }
           return rpt.id;

         */
        private static void applyFileFilter(Connection conn, Long profileId, long sessionId)
+       {
           try (Statement stmt = conn.createStatement())
           PreparedStatement stmt = null;
           ResultSet rs = null;
           try
+          {
              String sql;
              ResultSet rs;
              if (profileId != null)
+             {
                 // if profileId is null, the active_file was just created and is already empty;
                 // otherwise, delete all its records in preparation for re-population with the new
                 // filter profile's data
                 stmt.execute("delete from active_file where sid = " + sessionId);
                 stmt = conn.prepareStatement("delete from active_file where sid = ?");
                 stmt.setObject(1, sessionId);
                 stmt.executeUpdate();
+             }
              // Query file specs and types for the provided file filter profile; we will compose a
-...
              // If provided profile id was null, get the default profile.
              int i;
              int type = 0;
              // wildcard path specs first
              if (profileId == null)
-...
+             {
                 sql = "select f.spec from file_filter f " +
                       "join filter_profile p on p.id = f.pid " +
                       "where p.id = " + profileId + " and f.wild = true";
+             }
              rs = stmt.executeQuery(sql);
                       "where p.id = ?" + " and f.wild = true";
                 type = 1;
+             }
              if (stmt != null && !stmt.isClosed())
+             {
                 stmt.close();
+             }
              stmt = conn.prepareStatement(sql);
              if (type == 1)
+             {
                 stmt.setObject(1, profileId);
+             }
              type = 0;
              rs = stmt.executeQuery();
              List<Object> args = new ArrayList<>();
              StringBuilder buf = new StringBuilder("insert into active_file (fid, sid) ");
              for (i = 0; rs.next(); i++)
+             {
-...
                 buf.append("select distinct(f.id), ");
                 buf.append(sessionId);
                 buf.append(" from file f join ast_map a on a.fid = f.id where f.name like '");
                 buf.append(dbs.escapeLikeRValue(spec));
                 buf.setCharAt(buf.length() - 1, '%');
                 buf.append("'");
                 buf.append(" from file f join ast_map a on a.fid = f.id where f.name like ?");
                 String arg1 = dbs.escapeLikeRValue(spec);
                 arg1 = arg1.substring(0, arg1.length() - 1) + '%';
                 args.add(arg1);
+             }
              if (profileId == null)
-...
+             {
                 sql = "select f.spec from file_filter f " +
                       "join filter_profile p on p.id = f.pid " +
                       "where p.id = " + profileId + " and f.wild = false";
+             }
              rs = stmt.executeQuery(sql);
                       "where p.id = ?" + " and f.wild = false";
                 type = 1;
+             }
              if (rs != null && !rs.isClosed())
+             {
                 rs.close();
+             }
              if (stmt != null && !stmt.isClosed())
+             {
                 stmt.close();
+             }
              stmt = conn.prepareStatement(sql);
              if (type == 1)
+             {
                 stmt.setObject(1, profileId);
+             }
              type = 0;
              rs = stmt.executeQuery();
              int j = 0;
              for (; rs.next(); i++)
-...
                    buf.append(", ");
+                }
                 buf.append("'");
                 buf.append(spec);
                 buf.append("'");
                 args.add(spec);
                 if (++j == 100)
+                {
-...
+             }
              sql = buf.toString();
              stmt.execute(sql);
              if (rs != null && !rs.isClosed())
+             {
                 rs.close();
+             }
              if (stmt != null && !stmt.isClosed())
+             {
                 stmt.close();
+             }
              stmt = conn.prepareStatement(sql);
              for (int k = 0; k < args.size();k++)
+             {
                 stmt.setObject(k + 1, args.get(k));
+             }
              stmt.execute();
              int uc = stmt.getUpdateCount();
              System.out.println("applyActiveFile update count: " + uc);
-...
              throw new RuntimeException(exc);
+          }
           finally
+          {
              try
+             {
                 if (rs != null && !rs.isClosed())
+                {
                    rs.close();
+                }
                 if (stmt != null && !stmt.isClosed())
+                {
                    stmt.close();
+                }
+             }
              catch (SQLException e)
+             {
                 e.printStackTrace();
+             }
+          }
+       }
        /**
-...
           buf.append("insert into search_history ");
           buf.append("select * from (select next value for seq_search_history_pk, '");
           buf.append(criteria);
           buf.append("' ) x where not exists (select 1 from search_history where criteria = '");
           buf.append(criteria);
           buf.append("')");
           buf.append("' ) x where not exists (select 1 from search_history where criteria = ?)");
           Object histArg = criteria;
           String sqlInsSrchHist = buf.toString();
           // compose sql to insert into user_search table, if not already present
           buf.setLength(0);
           buf.append("insert into user_search select * from (select ");
           buf.append(user.getId());
           buf.append(" as u, select id from search_history where criteria = '");
           buf.append(criteria);
           buf.append("' as s) x where exists (select 1 from search_history where criteria = '");
           buf.append(criteria);
           buf.append("') and not exists (select 1 from user_search where uid = x.u and sid = x.s)");
           buf.append(" as u, select id from search_history where criteria = ?");
           buf.append(" as s) x where exists (select 1 from search_history where criteria = ?");
           buf.append(") and not exists (select 1 from user_search where uid = x.u and sid = x.s)");
           Object usrArg = criteria;
           String sqlInsUsrSrch = buf.toString();
           try (Statement stmt = conn.createStatement())
+          {
              // we use Statement instead of PreparedStatement here because we need a substitution
              // parameter in the select clauses of each statement, which H2 does not allow
              stmt.execute(sqlInsSrchHist);
              stmt.execute(sqlInsUsrSrch);
           //tested with H2 1.4.200 and prepared statements now work with subselects
           try (PreparedStatement stmt = conn.prepareStatement(sqlInsSrchHist))
+          {
              stmt.setObject(1, histArg);
              stmt.execute();
+          }
           try (PreparedStatement stmt = conn.prepareStatement(sqlInsUsrSrch))
+          {
              stmt.setObject(1, usrArg);
              stmt.setObject(2, usrArg);
              stmt.execute();
+          }
+       }

Project

General

Profile

FWD » Core Development » Database