FWD » Build and Source Control

** Copyright (c) 2017-2018, Golden Code Development Corporation.

    * @param    e

   void onFilter(ClickEvent e)

      // trigger for "Filter" dialog

      inputDialog.showFilterDialog(

                                    getUiHandlers().getCurrentFilter(),

                                    modalFragment,

                                    filter ->

                                    {

                                       getUiHandlers().setDataSelectionFilter(filter);

                                    });

** Copyright (c) 2017, Golden Code Development Corporation.

      inputDialog.showFilterDialog(

                                    getUiHandlers().getCurrentFilter(),

                                    modalFragment,

                                    filter ->

                                    {

                                       previewContainer.clear();

                                       previewContent.clearContent();

                                       previewContent.setRowCount(0, true);

                                       pager.setPageStart(0);

                                       getUiHandlers().setDataSelectionFilter(filter);

                                    });

** Copyright (c) 2017-2019, Golden Code Development Corporation.

*/

   /**

    * Builds and shows a filter input dialog.

    * TOOD: This method should not be here, InputDialog class should not handle any specific

    *       application logic.

    *

    * @param   filter

    *          The initial filter value.

    * @param   parent

    *          The modal dialog parent.

    * @param   actionHandler

    *          The callback called when the dialog is dismissed.

    */

   @Deprecated

   public void showFilterDialog(String filter, HasWidgets parent, Consumer<String> actionHandler)

   {

      String hlpText = "<h4>Define the filtering specification below. Press the&nbsp;" +

                       "'OK' button without any specification to remove any " +

                       "previous filter.</h4>";

      String label = "Filter";

      InputDialog.Field fFilter;

      build("Filter", hlpText, new InputDialog.Field[]

      {

         fFilter = new InputDialog.Field(label, filter, true)

      });

      show(parent, true, values ->

      {

         if (values != null)

         {

            actionHandler.accept((String) values.get(fFilter));

         }

      });

   }

** Copyright (c) 2017-2021, Golden Code Development Corporation.

*/

         SslContextFactory sslContextFactory = new SslContextFactory();

** Copyright (c) 2015-2019, Golden Code Development Corporation.

 * @deprecated Hibernate no longer in use; needs reimplementation or removal.

**     IAS 20220112          Resolve dialect by JDBC database type. 

         return IOUtils.toInputStream(data);

         Thread scanningThread = new Thread(new KeyScanner());

         scanningThread.setName("Identity pool scanning thread");

         scanningThread.setDaemon(true);

         scanningThread.start();

   /**

    * This helper class implements functionality of Identity pool scanning thread.

    */

   private class KeyScanner

   implements Runnable

   {

      /** Key retriever which is used to scan for available keys. */

      private KeyRetriever keyRetriever;

      /**

       * Performs periodical scanning for available keys.

       */

      public void run()

      {

         // Create and initialize key retriever.

         switch (scanMethod)

         {

            case JDBC:

               keyRetriever = new JdbcKeyRetriever();

               break;

            case STORED_PROCEDURE:

               keyRetriever = new StoredProcKeyRetriever();

               break;

            case NONE:

               return;

         }

         keyRetriever.initialize(database);

         Session session = null;

         // Main loop.

         while (true)

         {

            try

            {

               if (stopped)

               {

                  if (session != null)

                  {

                     session.close();

                  }

                  return;

               }

               if (session == null)

               {

                  session = new Session(database);

               }

               // Determine lower bound for scanning.

               long minKey = Math.max(maxKey - scanRange + 1, 1);

               long oldMaxKey = maxKey;

               // Move down the upper bound for scanning. Do it now because we

               // don't want to scan a range twice if any error has occurred.

               maxKey = minKey - 1;

               long startTime, endTime;

               List<Range> newKeys;

               try

               {

                  synchronized (currentlyScannedRange)

                  {

                     currentlyScannedRange.setBounds(minKey, oldMaxKey);

                  }

                  // Retrieve available keys.

                  startTime = System.currentTimeMillis();

                  newKeys = keyRetriever.retrieveFreeKeys(minKey, oldMaxKey, session);

                  endTime = System.currentTimeMillis();

               }

               finally

               {

                  synchronized (currentlyScannedRange)

                  {

                     currentlyScannedRange.makeEmpty();

                  }

               }

               int newKeysCount = 0;

               if (newKeys != null)

               {

                  for (Range range : newKeys)

                  {

                     newKeysCount += range.getRangeSize();

                  }

               }

               if (LOG.isLoggable(Level.FINE))

               {

                  LOG.log(Level.FINE,

                          "Range [" + minKey + ", " + oldMaxKey + "] was " +

                          "scanned in " + (endTime - startTime) + " ms. " +

                          newKeysCount + " free keys were found.");

                  if (newKeys != null)

                  {

                     for (Range range : newKeys)

                     {

                        LOG.log(Level.FINE, "Found range: " + range);

                     }

                  }

               }

               // Add recently retrieved keys to the main pool.

               long newPoolSize;

               synchronized (keysPool)

               {

                  if (newKeys != null)

                  {

                     // Get reclaimed keys that should be moved from reclaimed

                     // keys pool to the main keys pool.

                     SortedSet<Long> reclaimedKeysToMove =

                        reclaimedKeysPool.subSet(minKey, oldMaxKey + 1);

                     for (Range range : newKeys)

                     {

                        // Check whether some numbers in this range are

                        // already present in the reclaimed keys.

                        Iterator<Long> iter = reclaimedKeysToMove.iterator();

                        while (iter.hasNext())

                        {

                           Long key = iter.next();

                           if (range.contains(key))

                           {

                              // Key is also deleted for reclaimedKeysPool

                              // (because it backs reclaimedKeysToMove subset)

                              iter.remove();

                              poolSize--;

                           }

                        }

                     }

                     // Add remaining reclaimed keys to the ranges.

                     for (Long key : reclaimedKeysToMove)

                     {

                        newKeys.add(new Range(key));

                     }

                     // Get all handed out keys.

                     SortedSet<Long> allKeysInHands = handedOutKeys.subSet(minKey, oldMaxKey + 1);

                     allKeysInHands.addAll(pendingHandedOutKeys);

                     // Remove keys handed out from the new keys.

                     for (Range range : newKeys)

                     {

                        SortedSet<Long> extractedNumbers

                           = allKeysInHands.subSet(range.getLowerBound(),

                                                   range.getUpperBound() + 1);

                        if (extractedNumbers.isEmpty())

                        {

                           keysPool.add(range);

                           poolSize += range.getRangeSize();

                           if (LOG.isLoggable(Level.FINE))

                           {

                              LOG.log(Level.FINE, "Scanned range was added: " + range);

                           }

                        }

                        else

                        {

                           List<Range> subranges = range.splitRange(extractedNumbers);

                           for (Range subrange : subranges)

                           {

                              keysPool.add(subrange);

                              poolSize += subrange.getRangeSize();

                              if (LOG.isLoggable(Level.FINE))

                              {

                                 LOG.log(Level.FINE, "Scanned range was added: " + subrange);

                              }

                           }

                        }

                     }

                     // delete keys from reclaimedKeysPool (they have already 

                     // been moved to keysPool)

                     poolSize -= reclaimedKeysToMove.size();

                     reclaimedKeysToMove.clear();

                  }

                  pendingHandedOutKeys.clear();

                  newPoolSize = poolSize;

               }

               if (minKey == 1)

               {

                  if (LOG.isLoggable(Level.FINE))

                  {

                     LOG.log(Level.FINE, "The entire database has been scanned.");

                  }

                  session.close();

                  session = null;

                  return;

               }

               // Determine whether we have to perform next scan and time

               // delay before it.

               boolean performNextScan = false;

               int delay = 0;

               if (newPoolSize < scanThreshold)

               {

                  // We have the number of keys below the scanThreshold.

                  performNextScan = true;

                  // Double scan interval.

                  scanInterval = Math.min(scanInterval * 2, maximumScanInterval);

                  delay = Math.max(scanInterval, scanDelay);

               }

               else if (newPoolSize < targetSize)

               {

                  // We have the number of keys below the targetSize.

                  performNextScan = true;

                  delay = scanDelay;

               }

               if (!performNextScan)

               {

                  // Close the session since we do not know how soon the next

                  // scan will be performed.

                  session.close();

                  session = null;

                  if (LOG.isLoggable(Level.FINE))

                  {

                     LOG.log(Level.FINE, "Waiting for pool to shrink to scanThreshold.");

                  }

                  try

                  {

                     synchronized (waitLock)

                     {

                        if (stopped)

                        {

                           return;

                        }

                        waitLock.wait();

                     }

                  }

                  catch (InterruptedException e)

                  {

                     // Ignore.

                  }

               }

               else

               {

                  if (LOG.isLoggable(Level.FINE))

                  {

                     LOG.log(Level.FINE, "Next scan will be forced in " + delay + " seconds.");

                  }

                  if (delay > sessionHoldTime)

                  {

                     // Close the session if the next scan will not be performed soon enough.

                     session.close();

                     session = null;

                  }

                  if (delay > 0)

                  {

                     try

                     {

                        // Pause.

                        Thread.sleep(delay * 1000);

                     }

                     catch (InterruptedException e)

                     {

                        // Ignore.

                     }

                  }

               }

            }

            catch (PersistenceException exc)

            {

               if (session != null)

               {

                  try

                  {

                     session.close();

                  }

                  catch (PersistenceException exc2)

                  {

                     // ignore

                  }

               }

               LOG.log(Level.SEVERE,

                       "Identity pool has been stopped because of an exception:", exc);

               return;

            }

            catch (OutOfMemoryError oome)

            {

               try

               {

                  LOG.log(Level.SEVERE, "OOME into id pool scanning thread", oome);

                  // Some delay to let OOME disappear.

                  Thread.sleep(5000);

               }

               catch (OutOfMemoryError | InterruptedException e)

               {

                  // Ignore.

               }

            }

         }

      }

   }

      /** Retrieve keys using SQL queries */

      JDBC,

      /** Retrieve keys by calling a stored procedure */

      STORED_PROCEDURE,

/*

** Module   : JdbcKeyRetriever.java

** Abstract : KeyRetriever implementation which retrieves keys using SQL

**            queries.

**

** Copyright (c) 2005-2020, Golden Code Development Corporation.

**

** -#- -I- --Date-- --JPRM-- ----------------------------Description----------------------------

** 001 SVL 20080827  @39779  Created initial version. Retrieves free keys using two subsequent 

**                           queries.

** 002 SVL 20091126  @44444  Use external function for retrieving the list of database tables.

** 003 SVL 20120331          Upgraded to Hibernate 4.

** 004 OM  20140603          Use multiple queries in order to workaround the SQL Server limitation

**                           of maximum 2100 parameters per query.

** 005 OM  20151130          Adjusted the theoretical number of parameters per query to practical

**                           value.

** 006 ECF 20200906          Deprecated this class.

**                           TODO: eliminate dependencies and remove the class.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.persist.id;

import com.goldencode.p2j.persist.*;

import java.util.*;

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

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

//import com.goldencode.p2j.persist.type.*;

/**

 * Provides a service for retrieving available primary keys from database using SQL queries.

 * 

 * @deprecated Remove this class ASAP; this whole concept has turned out to be unsafe.

 */

public class JdbcKeyRetriever

implements KeyRetriever

{

   /** Query which returns the number of busy keys in the given range. */

   private String[] predictionQueries;

   /** Query which retrieves all busy keys in the given range. */

   private String[] retrievalQueries;

   /** The number of tables queried at once (in a single SQL statement). */

   private int bucketSize; 

   /**

    * Initialize key retriever for the given database.

    * Because the number of tables from a database may be too big (at least SQL Server has a

    * limitation of 2100 parameters in a query) the keys for the tables are retrieved in buckets.

    *

    * @param   database

    *          Database for which will be scanned for available keys.

    */

   @Override

   public void initialize(Database database)

   {

      /*

      // Get all table names.

      List<String> tableNames = DatabaseManager.getDatabaseTables(database);

      final int tableCount = tableNames.size();

      // Obtain the is the maximum number of tables that are scanned at in a single SQL query.

      Dialect dialect = DatabaseManager.getDialect(database);

      // There are 2 parameter for each table

      final int bucketSize = dialect.getMaxParameterCount() / 3; 

      // compute the necessary number of buckets to hold all tables

      int bucketCount;

      if (bucketSize <= 0)

      {

         // disable bucket-ing, all at once

         bucketCount = 1;

         this.bucketSize = tableCount;

      }

      else

      {

         if ((tableCount % bucketSize) == 0)

         {

            // no remainder / leftovers 

            bucketCount = tableCount / bucketSize;

         }

         else

         {

            // the remainder of tables go to extra bucket

            bucketCount = tableCount / bucketSize + 1;

         }

         this.bucketSize = bucketSize;

      }

      // debug only:

      // System.out.println("JdbcKeyRetriever is using bucketSize=" + this.bucketSize + 

      //   ", the queries (" + tableCount + ") will be split in " + bucketCount + " queries");

      predictionQueries = new String[bucketCount];

      retrievalQueries = new String[bucketCount];

      // Compose prediction queries which look like

      // 'select(

      //  (select count(id) from table1 where id >= :minId and id <= :maxId) +

      //  (select count(id) from table2 where id >= :minId and id <= :maxId) +

      //  ...) as cnt'

      // in the final step the subqueries intermediary result will be summed to a grand total

      int bucket = 0;

      StringBuilder buf = new StringBuilder("select (");

      for (int i = 0; i < tableCount; i++)

      {

         assert buf != null;

         buf.append("(select count(id) from ");

         buf.append(tableNames.get(i));

         buf.append(" where id >= :minId and id <= :maxId)");

         if (isLastInBucket(i, tableCount))

         {

            // bucket full, next bucket

            buf.append(") as cnt");

            predictionQueries[bucket] = buf.toString();

            ++bucket;

            // prepare for next bucket

            buf = (bucket != bucketCount) ? new StringBuilder("select (") : null;

         }

         else

         {

            // there are more items in this bucket

            buf.append(" + ");

         }

      }

      // Compose id retrieval query which looks like

      // 'select id from table1 where id >= :minId and id <= :maxId UNION

      //  select id from table2 where id >= :minId and id <= :maxId UNION

      //  ....  ORDER BY id asc'

      bucket = 0;

      buf = new StringBuilder();

      for (int i = 0; i < tableCount; i++)

      {

         assert buf != null;

         buf.append("select id from ");

         buf.append(tableNames.get(i));

         buf.append(" where id >= :minId and id <= :maxId");

         if (isLastInBucket(i, tableCount))

         {

            buf.append(" ORDER BY id asc");

            retrievalQueries[bucket] = buf.toString();

            ++bucket;

            buf = (bucket != bucketCount) ? new StringBuilder() : null;

         }

         else

         {

           // combine with other items from the current bucket

            buf.append(" UNION ");

         }

      }

      */

   }

   /**

    * Get available keys.

    * Each bucket is queried independently and the  the results are put back together.

    *

    * @param   minKey

    *          Lower bound of a range of identifiers on which search will be made.

    * @param   maxKey

    *          Upper bound of a range of identifiers on which search will be made.

    * @param   session

    *          Hibernate session which will be used to perform queries.

    *          

    * @return  a list of ranges of available keys

    */

   @Override

   public List<Range> retrieveFreeKeys(Long minKey, Long maxKey, Session session)

   {

      /*

      long rangeSize = maxKey - minKey + 1;

      long count = 0;

      for (String pQuery : predictionQueries)

      {

         // Execute prediction queries.

         SQLQuery query = session.createSQLQuery(pQuery);

         query.addScalar("cnt", StandardBasicTypes.LONG);

         query.setLong("minId", minKey);

         query.setLong("maxId", maxKey);

         // sum up the bucket subtotals

         count += (Long) query.uniqueResult();

      }

      if (count == 0L)

      {

         // All ids in the given range are free.

         List<Range> res = new ArrayList<>();

         res.add(new Range(minKey, maxKey));

         return res;

      }

      else if (count == rangeSize)

      {

         // No ids available.

         return null;

      }

      SortedSet<Long> busyKeys = new TreeSet<>();

      for (String rQuery : retrievalQueries)

      {

         // Execute the query which will return all busy ids in the given range.

         SQLQuery query = session.createSQLQuery(rQuery);

         query.addScalar("id", StandardBasicTypes.LONG);

         query.setLong("minId", minKey);

         query.setLong("maxId", maxKey);

         busyKeys.addAll((List<Long>) query.list());

      }

      return new Range(minKey, maxKey).splitRange(busyKeys);

      */

      return null;

   }

   /**

    * Checks if <code>i</code> is the last item in the bucket. Useful for combining items in a

    * bucket; the last item is usually handled differently.

    * 

    * @param   i

    *          The current item, related to global item array.

    * @param   size

    *          The global item array size.

    *          

    * @return  <code>true</code> if i is the last item in his bucket

    */

   private boolean isLastInBucket(int i, int size)

   {

      if (i == size - 1) 

      {

         // since this is the last item globally, it is also the last item in the last bucket

         return true;

      }

      // compute the position in the bucket

      int bucketPosition = i % this.bucketSize;

      return bucketPosition == this.bucketSize - 1;

   }

}

/*

** Module   : KeyRetriever.java

** Abstract : Interface for objects which retrieve available primary keys

**            from database.

**

** Copyright (c) 2005-2017, Golden Code Development Corporation.

**

** -#- -I- --Date-- --JPRM-- ---------------------------------Description----------------------------------

** 001 SVL 20080827   @39780 Created initial version. Defines interface

**                           to be used by objects which retrieve

**                           available primary keys from database.

** 002 ECF 20200906          New ORM implementation.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.persist.id;

import com.goldencode.p2j.persist.*;

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

import java.util.*;

/**

 * Interface which must be implemented by classes which provide service for

 * retrieving available primary keys from database.

 */

public interface KeyRetriever

{

   /**

    * Initialize key retriever for the given database.

    *

    * @param database

    *        Database for which will be scanned for available keys.

    */

   public void initialize(Database database);

   /**

    * Get available keys.

    *

    * @param  minKey

    *         Lower bound of a range of identifiers on which search will be

    *         made.

    * @param  maxKey

    *         Upper bound of a range of identifiers on which search will be

    *         made.

    * @param  session

    *         Hibernate session which will be used to perform queries.

    * 

    * @return A list of ranges of available keys

    */

   public List<Range> retrieveFreeKeys(Long minKey, Long maxKey, Session session);

}

/*

** Module   : StoredProcKeyRetriever.java

** Abstract : KeyRetriever implementation which retrieves keys using stored

**            procedure.

**

** Copyright (c) 2005-2020, Golden Code Development Corporation.

**

** -#- -I- --Date-- --JPRM-- ---------------------------------Description----------------------------------

** 001 SVL 20080827   @39782 Created initial version. Retrieves free keys

**                           using a stored procedure.

** 002 SVL 20120331          Upgraded to Hibernate 4.

** 003 ECF 20200906          Deprecated this class.

**                           TODO: eliminate any dependencies and remove this class.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.persist.id;

import com.goldencode.p2j.persist.*;

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

import java.util.*;

/**

 * Provides a service for retrieving available primary keys from database

 * by calling stored procedure.

 *

 * @deprecated

 */

public class StoredProcKeyRetriever

implements KeyRetriever

{

   /** Query which is used for stored procedure call. */

   private String retrieveQuery;

   /**

    * Name of the stored procedure used for id retrieval.

    * Procedure should be declared as 'FUNCTION procedure_name(min_id bigint, 

    * max_id bigint) RETURNS SETOF range_type'

    */

   private static String STORED_PROCEDURE_NAME = "get_free_ids";

   /**

    * Initialize key retriever for the given database.

    *

    * @param database

    *        Database for which will be scanned for available keys.

    */

   public void initialize(Database database)

   {

      StringBuilder buf = new StringBuilder();

      buf.append("select lower_bound, upper_bound from ");

      buf.append(STORED_PROCEDURE_NAME);

      buf.append("(:minId, :maxId)");

      retrieveQuery = buf.toString();

   }

   /**

    * Get available keys.

    *

    * @param  minKey

    *         Lower bound of a range of identifiers on which search will be

    *         made.

    * @param  maxKey

    *         Upper bound of a range of identifiers on which search will be

    *         made.

    * @param  session

    *         Hibernate session which will be used to perform queries.

    * @return A list of ranges of available keys

    */

   public List<Range> retrieveFreeKeys(Long minKey, Long maxKey, Session session)

   {

      // TODO: remove this and related classes; this concept has been shown to be unsafe

      /*

      // Execute the query which will return all ranges of free ids in the

      // given global range. 

      SQLQuery query = session.createSQLQuery(retrieveQuery);

      query.addScalar("lower_bound", StandardBasicTypes.LONG);

      query.addScalar("upper_bound", StandardBasicTypes.LONG);

      query.setLong("minId", minKey);

      query.setLong("maxId", maxKey);

      List<Range> res = new ArrayList<Range>();

      List<Object[]> bounds = (List<Object[]>) query.list();

      for (Object[] bound : bounds)

      {

         res.add(new Range((Long)bound[0], (Long)bound[1]));

      }

      return res;

      */

      return null;

   }

}

/**

 * Stubbed, temporary class for transition to new ORM implementation.

 * 

 * @deprecated Only used by deprecated, Hibernate-based, database statistics collector.

 */

/**

 * Stubbed, temporary class for transition to new ORM implementation.

 * @deprecated Only used by deprecated, Hibernate-based, database statistics collector.

 */

/**

 * Stubbed, temporary class for transition to new ORM implementation.

 * @deprecated Only used by deprecated, Hibernate-based, database statistics collector.

 */

** Copyright (c) 2017-2021, Golden Code Development Corporation.

**     VVT 20210917 Javadoc fixed. 

      this.acmeServerUri = acmeServerUri;

      this.host          = host;

      this.port          = port;