FWD » Core Development » Database

package com.goldencode.p2j.persist.dirty;

import com.goldencode.p2j.persist.*;

import com.goldencode.p2j.persist.event.*;

import com.goldencode.p2j.persist.lock.*;

import com.goldencode.p2j.util.*;

import java.util.*;

public class NopDirtyShareContext

extends DirtyShareContext

{

   /**

    * Default constructor.

    */

   NopDirtyShareContext()

   {

      super(null);

   }

   /**

    * NOP in this implementation.

    *

    * Register with a global event clearinghouse an interest in insert,

    * delete, and update events which affect the given DMO entity.

    *

    * @param   entity

    *          DMO entity for which the caller is interested in tracking

    *          change.

    *

    * @return  always <code>null</code> in this implementation.

    *

    * @see     #getGlobalEvents(long, long)

    * @see     #deregisterForGlobalEvents(long)

    */

   @Override

   public Long registerForGlobalEvents(String entity)

   {

      return null;

   }

   /**

    * NOP in this implementation.

    *

    * Deregister with a global event clearinghouse an interest in insert,

    * delete, and update events which affect a particular DMO type.

    *

    * @param   registerID

    *          A unique identifier for the registrant being deregistered.

    *

    * @see     #getGlobalEvents(long, long)

    * @see     #registerForGlobalEvents(String)

    */

   @Override

   public void deregisterForGlobalEvents(long registerID)

   {

   }

   /**

    * NOP in this implementation.

    *

    * Retrieve any new events that have been collected by a global event

    * clearinghouse, representing inserts, deletes, and updates made to

    * record types for which the caller previously has registered interest.

    *

    * @param   registerID

    *          A unique identifier for an object which has registered interest

    *          in record-changing events.

    * @param   lastID

    *          A unique identifier representing the last event retrieved by

    *          the caller.  If less than 0, it is assumed no events have yet

    *          been retrieved since the caller registered interest in these

    *          events.

    *

    * @return  always <code>null</code> in this implementation.

    */

   @Override

   public GlobalChangeEvent[] getGlobalEvents(long registerID, long lastID)

   {

      return null;

   }

   /**

    * NOP in this implementation.

    *

    * Lock or unlock all indexes associated with the given DMO entity.

    *

    * @param   entity

    *          Name of an entity, which is the name of the DMO implementation

    *          class associated with a table being tracked for uncommitted

    *          changes.

    * @param   lockType

    *          Type of lock to acquire, or <code>NONE</code> to release

    *          existing locks.  <code>NO_WAIT</code> variants will be treated

    *          as regular, blocking variants.

    */

   @Override

   public void lockAllIndexes(String entity, LockType lockType)

   {

   }

   /**

    * NOP in this implementation.

    *

    * Begin tracking a newly inserted record in the dirty database.

    * <p>

    * This record is removed when the adding context's current transaction is committed or rolled back.

    *

    * @param   buffer

    *          Record buffer responsible for the insert.

    * @param   dmo

    *          Record to be tracked.

    * @param   lock

    *          {@code true} to acquire write locks to insert the record;

    *          {@code false} to assume write locks are acquired by calling code.

    */

   @Override

   public void insert(RecordBuffer buffer, Record dmo, boolean lock)

   {

   }

   /**

    * NOP in this implementation.

    *

    * Indicate whether the specified record is being tracked as newly inserted

    * by this context.

    *

    * @param   ident

    *          Record identifier of the record to be checked.

    *

    * @return  always {@code false} in this implementation.

    */

   @Override

   public boolean isTracked(RecordIdentifier<String> ident)

   {

      return false;

   }

   /**

    * NOP in this implementation.

    *

    * If the specified record is an unvalidated insert created by a buffer local to this context,

    * get the buffer which created it.

    *

    * @param   ident

    *          Record identifier of the record to be checked.

    *

    * @return  always <code>null</code> in this implementation.

    */

   @Override

   public RecordBuffer getCreatingBuffer(RecordIdentifier<String> ident)

   {

      return null;

   }

   /**

    * NOP in this implementation.

    *

    * Rollback the insert of a record previously introduced with the {@link

    * #insert(RecordBuffer, Record, boolean)} method.

    *

    * @param   ident

    *          Identifier for the target record, which encapsulates its entity

    *          name and primary key.

    * @param   lock

    *          <code>true</code> to acquire write locks;

    *          <code>false</code> to assume write locks are acquired by

    *          calling code.

    */

   @Override

   public void rollbackInsert(RecordIdentifier<String> ident, boolean lock)

   {

   }

   /**

    * NOP in this implementation.

    *

    * Notify this object that a record was inserted into database and should not be tracked any more in

    * {@code earlyInserts}.

    *

    * @param   id

    *          The identifier of the record.

    */

   @Override

   public void recordInserted(RecordIdentifier<String> id)

   {

   }

   /**

    * NOP in this implementation.

    *

    * Track an update to one or more indexed, DMO properties, as indicated by the

    * {@code properties}, {@code extIndexes} and {@code values} arguments.

    * <p>

    * Any record added to the dirty database as a result of this method is removed when the adding

    * context's current transaction is committed or rolled back.

    * <p>

    * Assumes appropriate indexes have been locked by the caller.

    *

    * @param   buffer

    *          Record buffer responsible for the update.

    * @param   properties

    *          Array of names of those DMO properties which were updated. These should represent

    *          columns which participate in one or more indexes.

    * @param   extIndexes

    *          In case of EXTENT fields this array contains their index. Otherwise -1.

    * @param   values

    *          Updated DMO property values.  Each value in the array corresponds positionally with

    *          its matching property name in the {@code properties} array.

    * @param   transientIndexValidated

    *          {@code true} if the update was caused by an index validation of a transient record.

    */

   @Override

   public void update(RecordBuffer buffer,

                      String[] properties,

                      int[] extIndexes,

                      BaseDataType[] values,

                      boolean transientIndexValidated)

   {

   }

   /**

    * NOP in this implementation.

    *

    * Mark a record as having been deleted in an uncommitted transaction, or

    * unmark a record which previously was so marked.

    * <p>

    * If marking a record as deleted, that was earlier inserted by the current

    * context, rollback the insert, but do not mark the record as deleted.

    * <p>

    * A record is unmarked when the adding context's current transaction is

    * committed or rolled back.

    *

    * @param   entity

    *          Name of an entity, which is the name of the DMO implementation

    *          class associated with a table being tracked for uncommitted

    *          changes.

    * @param   id

    *          Primary key of deleted record.

    * @param   rollback

    *          If <code>false</code>, the target record is marked as deleted;

    *          if <code>true</code>, it is unmarked.

    * @param   lock

    *          <code>true</code> to acquire write locks to delete the record;

    *          <code>false</code> to assume write locks are acquired by

    *          calling code.

    */

   @Override

   public void delete(String entity, Long id, boolean rollback, boolean lock)

   {

   }

   /**

    * NOP in this implementation.

    *

    * Indicate whether there are currently any uncommitted changes (inserts,

    * updates, or deletes) in the table represented by the given DMO entity

    * name.

    *

    * @param   entity

    *          Fully qualified name of the DMO entity to be checked.

    *

    * @return  always {@code false} in this implementation.

    */

   @Override

   public boolean isEntityDirty(String entity)

   {

      return false;

   }

   /**

    * NOP in this implementation.

    *

    * Indicate whether the record specified by the given entity and primary key has

    * been deleted within an uncommitted transaction within a context, optionally

    * ignoring deletes in the current context.

    *

    * @param   entity

    *          Name of an entity, which is the name of the DMO implementation

    *          class associated with a table being tracked for uncommitted

    *          changes.

    * @param   id

    *          Primary key of the record to be checked.

    * @param   ignoreLocal

    *          Ignore a delete if it occurred in the current context and only report

    *          whether a delete of the given record occurred in a different context.

    *

    * @return  always {@code false} in this implementation.

    */

   @Override

   public boolean isDirtyDelete(String entity, Long id, boolean ignoreLocal)

   {

      return false;

   }

   /**

    * NOP in this implementation.

    *

    * Retrieve from the dirty database the record specified by the given

    * entity and primary key, if it exists, and if it was not put there by the

    * current context.

    *

    * @param   entity

    *          Name of an entity, which is the name of the DMO implementation

    *          class associated with a table being tracked for uncommitted

    *          changes.

    * @param   id

    *          Primary key of the record to be retrieved.

    *

    * @return  always {@code null} in this implementation.

    */

   @Override

   public Record getDirtyDMO(String entity, Long id)

   {

      return null;

   }

   /**

    * NOP in this implementation.

    *

    * Execute an HQL query and return the results as a list.  If the query returns multiple

    * results per row, each element in the list will be an array of {@code Object}s.

    * <p>

    * No locking is attempted.

    *

    * @param   entity

    *          Name of an entity, which is the name of the DMO implementation class associated

    *          with a table being tracked for uncommitted changes. Should be {@code null}

    *          for a multi-table query.

    * @param   fql

    *          FQL query statement. This method makes no assumptions as to the types of object(s) returned.

    * @param   params

    *          Substitution values for the query. If none, this should be an empty array.

    * @param   maxResults

    *          The maximum number of elements to be returned in the list. If this value is

    *          non-positive, no upper limit is applied.

    * @param   startOffset

    *          The 0-based offset of the first record to retrieve.  If this value is non-positive,

    *          an offset of 0 is used by default.

    * @param   readOnly

    *          {@code true} to execute the query in read-only mode, else {@code false}.

    *

    * @return  always {@code null} in this implementation.

    */

   @Override

   public <T> List<T> list(String entity,

                           String fql,

                           Object[] params,

                           int maxResults,

                           int startOffset,

                           boolean readOnly)

   {

      return null;

   }

   /**

    * NOP in this implementation.

    *

    * Given certain search criteria and possibly a potential DMO match in the primary database,

    * report any significant information currently being tracked for uncommitted transactions,

    * which might override data (or the lack thereof) found in the primary database.

    * <p>

    * If a {@link DirtyInfo} object is returned by this method, it will contain overriding

    * information, such as a dirty DMO which matched the search criteria, whether that record was

    * newly inserted, or the fact that the candidate record found in the primary search has been

    * deleted or modified in an uncommitted transaction.  A {@code null} return indicates no

    * overriding information was available.

    *

    * @param   buffer

    *          Record buffer associated with the current query.

    * @param   index

    *          UID of index which governs the ordering of data in the current query.

    * @param   queryType

    *          Type of query.

    * @param   bundle

    *          An object containing one or more FQL statements to be executed against the dirty

    *          database to find a record which matches the current query criteria.  The list is in

    *          order of most specific to least specific search criteria.

    * @param   params

    *          Query substitution parameters which match placeholders in the most specific FQL

    *          statement.

    * @param   found

    *          DMO, if any, found in the primary database, which matches the current query criteria.

    * @param   byRowid

    *          The predicate of the query does a lookup for ROWID/RECID of the table. In case of

    *          transient records they are accessible without the need of having a full matched

    *          index.

    *

    * @return  always {@code null} in this implementation.

    */

   @Override

   public DirtyInfo getDirtyInfo(RecordBuffer buffer,

                                 int index,

                                 int queryType,

                                 FQLBundle bundle,

                                 Object[] params,

                                 Record found,

                                 boolean byRowid)

   {

      return null;

   }

   /**

    * NOP in this implementation.

    *

    * Clean up all information contributed to the dirty share manager by this context for the current

    * transaction.  This method is called when a full database transaction has been committed or rolled back

    * against the primary database.  It is also invoked when the client context ends.  It removes all records

    * it added to the dirty database for new inserts, updates, and deletes.

    */

   @Override

   public void cleanup()

   {

   }

}