6695.patch

        protected void fetch(boolean available, LockType lockType, boolean errorIfNull)
        throws MissingRecordException
+       {
           if (available && getResults().isAutoFetch())
+          {
              return;
+          }
           super.fetch(available, lockType, errorIfNull);
           if (!isScrolling() && !foundFirst && available && offEnd == OffEnd.NONE)
-...
+          }
           /**
            * Is the result delegate responsible for fetching? This is usually true when using
            * query delegates which handle the fetching process already.
+           *
            * @return   {@code true} for complex results which also do the fetching
+           *
            */
           @Override
           public boolean isAutoFetch()
+          {
              return true;
+          }
           /**
            * Get the array of objects at the current result row.
+           *
            * @return  Object array or <code>null</code>.
            */
           public Object[] get()
+          {
              int len = buffers.length;
              Object[] row = new Object[len];
              for (int i = 0; i < len; i++)
              return get(null);
+          }
           /**
            * Get the array of objects at the current result row if lazy fetching allows it.
+           *
            * @param   fetching
            *          The instance responsible with lazy fetching.
            * @return  Object array or <code>null</code>.
            */
           public Object[] get(LazyFetching fetching)
+          {
              // if lazy fetching is not intended at all or
              // if lazy fetching is intended and the record is OK to be used
              if (fetching == null || fetching.isFullRecordOk())
+             {
                 row[i] = get(i);
                 int len = buffers.length;
                 Object[] row = new Object[len];
                 for (int i = 0; i < len; i++)
+                {
                    row[i] = get(i);
+                }
                 return row;
+             }
              return row;
              throw new IllegalStateException("This kind of Results does not support lazy fetching");
+          }
           /**

     **     OM  20220530          Fixed flush of nursery (only the affected index).
     **     OM  20220701          Flatten calls to initialize().
     **     CA  20221006          Added JMX instrumentation for query assemble. Refs #6814
     **     RAA 20221010          Added class PreselectLazyFetching which enables the possibility of lazy fetching
     **                           for Preselect queries on temporary no-undo tables.
     **     CA  20221013          In 'repositionByID', if the row number is after the last row in the ResultSet,
     **                           assume an error (query off-end) and do not try to fetch the record.
     */
-...
        /** Has query been registered for resource cleanup? */
        private boolean regCleaner = false;
        /** Instance of lazy fetching. */
        private LazyFetching fetching = new PreselectLazyFetching();
        /** Cleaner executed when this query's block is exit. */
        private final Finalizable cleaner = new Finalizable()
+       {
-...
+             }
              else
+             {
                 Object[] data = available ? results.get() : null;
                 coreFetch(data, lockType, errorIfNull, false);
                 if (!results.isAutoFetch())
+                {
                    Object[] data = available ? results.get(fetching) : null;
                    coreFetch(data, lockType, errorIfNull, false);
+                }
                 if (available)
+                {
-...
+       {
           int recFetched = 0;
           Iterator<QueryComponent> iter = components();
           boolean isTemporary = persistence.isTemporary();
           for (int i = 0; iter.hasNext(); i++)
+          {
              QueryComponent comp = iter.next();
              RecordBuffer buffer = comp.getBuffer();
              if (isTemporary && !((TemporaryBuffer)buffer).isUndoable() && data != null && data[i] == null)
+             {
                 recFetched++;
                 continue;
+             }
              boolean dirtyCopy = false;
              Record dmo = null;
              LockType lt = lockType;
-...
           @Override
           public Object[] get()
+          {
              return (cursor == 0) ? new Object[] { templateRowid } : null;
              return get(null);
+          }
           /**
            * Get the array of objects at the current result row if lazy fetching allows it.
+           *
            * @param   fetching
            *          The instance responsible with lazy fetching.
            * @return  Object array or {@code null}.
            */
           @Override
           public Object[] get(LazyFetching fetching)
+          {
              if (cursor != 0)
                 return null;
              // if lazy fetching is not intended at all or
              // if lazy fetching is intended and the record is OK to be used
              if (fetching == null || fetching.isFullRecordOk())
+             {
                 return new Object[] { templateRowid };
+             }
              throw new IllegalStateException("This kind of Results does not support lazy fetching");
+          }
           /**
-...
              // else cursor is -1 (before), 0 (on single record), 1 (after)
+          }
+       }
        /**
         * Class that implements the concept of {@link LazyFetching} for {@link PreselectQuery}.
         * It provides a quick response as to whether a {@link Record} should be lazy fetched or not.
         */
        class PreselectLazyFetching
        implements LazyFetching
+       {
           /**
            * Method to check if a {@link Record} should be fully/partially fetched or not.
            * Fully fetched means that a {@code Record} should be retrieved from the database,
            * partially fetched means that a {@code Record} should be retrieved from the cache.
+           *
            * @param   comp
            *          The number of the {@link QueryComponent} for which we check it's {@link RecordBuffer}.
            * @param   id
            *          The id of the {@code Record} that is about to be put in the {@code RecordBuffer}.
            * @return  {@code true} if a {@code Record} should be fully/partially fetched,
            *          {@code false} otherwise.
            */
           @Override
           public boolean shouldFetch(Integer comp, Long id)
+          {
              QueryComponent component = components.get(comp);
              RecordBuffer buffer = component.getBuffer();
              if (!buffer.isTemporary() || ((TemporaryBuffer)buffer).isUndoable())
+             {
                 return true;
+             }
              return component.checkFetching(id);
+          }
           /**
            * Setter for the {@code oldId}, which is responsible with knowing the id of the
            * last {@code Record} that was inside the {@link RecordBuffer}.
+           *
            * @param   comp
            *          The number of the {@link QueryComponent} for which we check it's {@code RecordBuffer}.
            * @param   id
            *          The id of the old {@code Record}.
            */
           @Override
           public void setOldId(Integer comp, Long id)
+          {
              components.get(comp).setOldId(id);
+          }
           /**
            * Method for checking if the {@code Record} is hydrated or is affected by lazy fetching.
+           *
            * @return  {@code true} if the {@code Record} is hydrated and is OK to be used,
            *          {@code false} otherwise.
            */
           @Override
           public boolean isFullRecordOk()
+          {
              return true;
+          }
+       }
+    }

     import java.io.*;
     import java.util.*;
     import com.goldencode.p2j.persist.lock.*;
     import com.goldencode.p2j.persist.orm.LazyFetching;
     import com.goldencode.p2j.util.*;
     /**
-...
            */
           public Object[] get()
+          {
              return row;
              return get(null);
+          }
           /**
            * Get the array of objects at the current result row if lazy fetching allows it.
+           *
            * @param   fetching
            *          The instance responsible with lazy fetching.
            * @return  Object array or <code>null</code>.
            */
           public Object[] get(LazyFetching fetching)
+          {
              // if lazy fetching is not intended at all or
              // if lazy fetching is intended and the record is OK to be used
              if (fetching == null || fetching.isFullRecordOk())
+             {
                 return row;
+             }
              throw new IllegalStateException("This kind of Results does not support lazy fetching");
+          }
           /**

     import java.util.function.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.persist.event.SessionListener;
     import com.goldencode.p2j.persist.orm.LazyFetching;
     /**
      * This helper class performs client-side (i.e., relative to the database
-...
            */
           public Object[] get()
+          {
              return get(null);
+          }
           /**
            * Get the array of objects at the current result row if lazy fetching allows it.
+           *
            * @param   fetching
            *          The instance responsible with lazy fetching.
            * @return  Object array or <code>null</code>.
            */
           public Object[] get(LazyFetching fetching)
+          {
              if (scrolling)
+             {
                 return super.get();
                 return super.get(fetching);
+             }
              else
+             {
                 Object[] datum = (Object[]) currentRow;
                 return datum;
                 // if lazy fetching is not intended at all or
                 // if lazy fetching is intended and the record is OK to be used
                 if (fetching == null || fetching.isFullRecordOk())
+                {
                    Object[] datum = (Object[]) currentRow;
                    return datum;
+                }
                 throw new IllegalStateException("Record is not hydrated and should be, in order to be used");
+             }
+          }

     import java.util.*;
     import java.util.logging.*;
     import com.goldencode.p2j.persist.event.*;
     import com.goldencode.p2j.persist.orm.LazyFetching;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.ErrorManager;
-...
         */
        public Object[] get()
+       {
           return get(null);
+       }
        /**
         * Get the array of objects at the current result row.
+        *
         * @param   fetching
         *          The instance responsible with lazy fetching.
         * @return  Object array or <code>null</code>.
         */
        public Object[] get(LazyFetching fetching)
+       {
           if (position < 0)
+          {
              return null;
+          }
           // we can use cache if lazy fetching is not intended at all or
           // if lazy fetching is intended and the record is OK to be used
           boolean canUseCache = fetching == null || fetching.isFullRecordOk();
           // If we have a cache and it contains the requested record, retrieve from the cache.
           if (cache != null && position < cache.size())
           if (canUseCache && cache != null && position < cache.size())
+          {
              return cache.get(position);
+          }
-...
              Results results = getResults(bracket);
              if (results != null)
+             {
                 return results.get();
                 return results.get(fetching);
+             }
+          }
           catch (Exception exc)

        /** Index information string as it is returned by INDEX-INFORMATION. */
        private String indexInfo = null;
        /** The id of the old Record that was in the buffer. */
        private Long oldId = null;
        /**
         * The list of dynamic filters. These are filters added dynamically, at runtime and can also be
         * removed dynamically.
-...
+       }
        /**
         * Method used for checking if fetching is necessary for this component.
+        *
         * @param   id
         *          The id of the {@code Record} that will potentially be fetched.
         * @return  true if the buffer needs to fetch this record, or false otherwise.
         */
        public boolean checkFetching(Long id)
+       {
           Record record = buffer.getCurrentRecord();
           if (record == null)
+          {
              return true;
+          }
           Long bufferId = record.getId();
           if (bufferId != null && id.equals(bufferId) && id.equals(oldId))
+          {
              return false;
+          }
           return true;
+       }
        /**
         * Setter for the old record's id.
+        *
         * @param   id
         *          The id of the record that was just fetched.
         */
        public void setOldId(Long id)
+       {
           oldId = id;
+       }
        /**
         * Set the record buffer for this component's query.
+        *
         * @param    buffer

     package com.goldencode.p2j.persist;
     import com.goldencode.p2j.persist.orm.LazyFetching;
     /**
      * An abstraction layer between a joinable query implementation and its results.  This interface
      * defines methods for manipulating a results set using a scrollable cursor paradigm.  Each row
-...
        public boolean isLast();
        /**
         * Method to implement if lazy fetching is intended. By default, this is not the case.
+        *
         * @return  {@code false} by default. If lazy fetching is intended, then this method needs
         *          to be implemented to return {@code true}.
         */
        default public boolean isAutoFetch()
+       {
           return false;
+       }
        /**
         * Get the array of objects at the current result row.
+        *
         * @return  Object array or {@code null}.
-...
        public Object[] get();
        /**
         * Get the array of objects at the current result row. The default method involves no lazy fetching.
         * If lazy fetching is desired, then this method needs to be implemented.
+        *
         * @param   fetching
         *          The instance responsible with lazy fetching.
         * @return  Array of {@code Object}s and {@code null}s.
         */
        default public Object[] get(LazyFetching fetching)
+       {
           if (fetching != null)
+          {
              throw new IllegalStateException(this.getClass().getName() +
                                              " does not implement get() with onlyDifferences.");
+          }
           return get();
+       }
        /**
         * Get the object at the current result row, at the specified column.
+        *
         * @param   column
-...
+       {
           throw new IllegalStateException("Cannot add a row for this type of results");
+       }
+    }
+    }

     import java.io.*;
     import com.goldencode.p2j.persist.orm.LazyFetching;
     /**
      * An implementation of the {@code Results} interface which delegates all work to another {@code
      * Results} implementation.  A worker can be connected at any time using {@link #setResults}, or
-...
+       }
        /**
         * Is the result delegate responsible for fetching? This is usually true when using
         * query delegates which handle the fetching process already.
+        *
         * @return   {@code true} for complex results which also do the fetching
+        *
         */
        @Override
        public boolean isAutoFetch()
+       {
           return results.isAutoFetch();
+       }
        /**
         * Get the array of objects at the current result row.
+        *
         * @return  Object array or {@code null}.
-...
+       {
           return results.get();
+       }
        /**
         * Get the array of objects at the current result row if lazy fetching allows it.
+        *
         * @param   fetching
         *          The instance responsible with lazy fetching.
         * @return  Object array or {@code null}.
         */
        public Object[] get(LazyFetching fetching)
+       {
           return results.get(fetching);
+       }
        /**
         * Get the object at the current result row, at the specified column.
-...
              provider.provideNewResults(this);
+          }
+       }
+    }
+    }

+       }
        /**
         * Get an array of objects or nulls at the current result row if lazy fetching allows it.
+        *
         * @param   fetching
         *          The instance responsible with lazy fetching.
         * @return  Object array or <code>null</code>.
         */
        public Object[] get(LazyFetching fetching)
+       {
           return results.get(fetching);
+       }
        /**
         * Get the object at the current result row, at the specified column.
+        *
         * @param   column

     import java.util.*;
     import com.goldencode.p2j.persist.orm.LazyFetching;
     /**
      * A simple implementation of {@code Results} which stores row data in a list provided to the
      * constructor. The row data consists of a list of array objects. Each object in the array is
-...
         */
        public Object[] get()
+       {
           return get(null);
+       }
        /**
         * Get the array of objects at the current result row if lazy fetching allows it.
+        *
         * @param   fetching
         *          The instance responsible with lazy fetching.
         * @return  Object array or {@code null}.
         */
        public Object[] get(LazyFetching fetching)
+       {
           if (position < 0 || position > getNumberOfLoadedRows() - 1)
+          {
              return null;
+          }
           Object res = rows.get(position);
           if (res instanceof Object[])
+          {
              return (Object[]) res;
+          }
           else
+          {
               return new Object[] { res };
+          }
+       }
           // if lazy fetching is not intended at all or
           // if lazy fetching is intended and the record is OK to be used
           if (fetching == null || fetching.isFullRecordOk())
+          {
              Object res = rows.get(position);
              if (res instanceof Object[])
+             {
                 return (Object[]) res;
+             }
              else
+             {
                  return new Object[] { res };
+             }
+          }
           throw new IllegalStateException("This kind of Results does not support lazy fetching");
+       }
        /**
         * Get the object at the current result row, at the specified column.

+       }
        /**
         * Getter for the id of the current record.
+        *
         * @return  id
         *          The id that was requested.
         */
        public Long getId()
+       {
           return id;
+       }
        /**
         * Indicate whether any of this record's validatable properties are dirty and have not been validated.
+        *
         * @return  {@code true} if record needs validation, else {@code false}.

         * @param   session
         *          The {@code Session} to be used.
         */
        public ScrollableResults(Statement stmt, ResultSet rs, List<RowStructure> rowStructure, Session session)
        public ScrollableResults(Statement stmt,
                                 ResultSet rs,
                                 List<RowStructure> rowStructure,
                                 Session session)
+       {
           this.stmt = stmt;
           this.rs = rs;
-...
+       }
        /**
         * Obtain the full set of values on current row. An array of primary keys or full {@code Record} will be
         * returned.
         * Obtain the full set of values on current row. An array of primary keys or full {@code Record}s,
         * or {@code null}s will be returned. First two cases correspond to the need of fetching,
         * while {@code null} means that no fetching is necessary for that component.
+        *
         * @param   fetching
         *          The instance responsible with lazy fetching.
+        *
         * @return  An array of {@code Object} s if the cursor is on a valid position. Otherwise {@code null} is
         *          returned. The type of returned elements may be both {@code Long} when an array of PKs (recids)
         *          is queried or an array of full {@code Record}s. The caller is responsible for handling both
         *          cases (including hydration, if needed).
         */
        public Object[] get()
        public Object[] get(LazyFetching fetching)
+       {
           return execute(() ->
+          {
              int rowSize = (rowStructure == null) ? 0 : rowStructure.size();
-...
                 ret = new Object[rowSize];
                 int rsOffset = 1;
                 int recCnt = 0;
                 for (RowStructure rowStruct : rowStructure)
+                {
                    int expColumnCount = rowStruct.count;
                    Long object = rs.getLong(rsOffset);
                    //if fetching is not null, lazy fetching is intended
                    if (fetching != null)
+                   {
                       if (object != null && !fetching.shouldFetch(recCnt, object))
+                      {
                          ret[recCnt] = null;
                          // position on next record
                          rsOffset += expColumnCount;
                          ++recCnt;
                          continue;
+                      }
+                   }
                    try
+                   {
                       ret[recCnt] =
                          SQLQuery.hydrateRecord(rs, rowStruct.dmoClass, rsOffset, expColumnCount, session);
                       if (fetching != null)
+                      {
                          fetching.setOldId(recCnt, object);
+                      }
+                   }
                    catch (PersistenceException e)
+                   {
-...
+       }
        /**
         * Obtain the full set of values on current row. An array of primary keys or full {@code Record} will be
         * returned.
+        *
         * @return  An array of {@code Object} s if the cursor is on a valid position. Otherwise {@code null} is
         *          returned. The type of returned elements may be both {@code Long} when an array of PKs (recids)
         *          is queried or an array of full {@code Record}s. The caller is responsible for handling both
         *          cases (including hydration, if needed).
         */
        public Object[] get()
+       {
           return get(null);
+       }
        /**
         * Obtain the selection of values on current row.
+        *
         * @param    dmoInfo

Project

General

Profile

FWD » Core Development » Database