FWD » Core Development » Database

** 011 DDF 20230201          Refactored ParameterIndices into ParameterDiff. (refs: #7035)

   /** Mapping of substitution parameters functions */

   private ParameterDiff paramDiff = null;

    * Get the <code>ParameterDiff</code> object associated with this

    * array of query substitution parameters lambdas for the base (i.e., unaugmented)

    * @return  An object which provides a mapping of query substitution parameter

    *          functions.

   ParameterDiff getParameterDiff()

      return paramDiff;

    * Set the <code>ParameterDiff</code> object associated with this

    * array of query substitution parameters lambdas for the base (i.e., unaugmented)

    *          An object which provides a mapping of query substitution parameter

    *          functions.

   void setParameterDiff(ParameterDiff paramDiff)

      this.paramDiff = paramDiff;

**     DDF 20230201          Method call changed due to method refactoring of FQLBundle and 

**                           FQLPreprocessor. (refs: #7035)

      // Store query substitution parameter lambdas.

      // to change, we would need to maintain separate ParameterDiff

         bundle.setParameterDiff(fqlPreprocessor.getParameterDiff());

**     DDF 20230201          Extracted query parameters from the where clause and refactored ParameterIndices

**                           into ParameterDiff to store a mapping of substitution parameter lambdas for all

**                           parameters (parameters given at query initialization and the ones extracted 

**                           from the AST). (refs: #7035)

 *   <li>{@link #getParameterDiff()}

   /** Mapping of substitution parameters functions after rewrite */

   private ParameterDiff paramDiff = null;

   /** List of extracted parameters from the where clause */

   private List<Object> parametersDiff = null;

    * Get the <code>ParameterDiff</code> object associated with this query.

    * query substitution parameter lambdas for the where clause, as it exists

    *          substitution parameter lambdas list.

   ParameterDiff getParameterDiff()

      return paramDiff;

         this.paramDiff = createParameterDiffs(root, parameters);

      int parameterCounter = parameters != null ? parameters.length : 0;

      FqlType parameterType = null;

            // The BOOL_TRUE and BOOL_FALSE cases are not handled because are duplicates

            // Change node type to SUBST for future prepared statement processing

            case NUM_LITERAL:

               if (parameterType == null)

               {

                  parameterType = FqlType.INTEGER;

               }

            case DEC_LITERAL:

               if (parameterType == null)

               {

                  parameterType = FqlType.DECIMAL;

               }

            case STRING:

               if (parameterType == null)

               {

                  parameterType = FqlType.TEXT;

               }

               // Add an index and datatype annotation to the current node.

               // The extracted-value annotation stores the value of the node.

               next.putAnnotation("index", (long) parameterCounter++);

               next.putAnnotation("datatype", parameterType.toString());

               next.putAnnotation("extracted-value", next.getText());

               if (parametersDiff == null)

               {

                  parametersDiff = new ArrayList<>();

               }

               parametersDiff.add(next.getText());

               parameterType = null;

               // Change the node type and value

               next.setType(SUBST);

               next.setText("?");

               // Stop the inline of the extracted parameters.

               break;

    * Create the mapping of substitution parameters functions to their corresponding

    * parameter placeholder), and each <code>NUM_LITERAL</code>, <code>DEC_LITERAL</code>,

    * <code>STRING</code> which is substituted to <code>SUBST</code> 

    * denoting that placeholder's lambda in the original where clause.  

    * We now walk the rewritten AST, extracting this annotation

    * and storing it in a new list.  The resulting array defines

   private ParameterDiff createParameterDiffs(HQLAst root, Object[] parameters)

      // If there are no arguments or substituted parameters

      if (parameters == null && parametersDiff == null)

         return (new ParameterDiff(null));

      int paramCounter = parameters != null ? parameters.length : 0;

      paramCounter += parametersDiff != null ? parametersDiff.size() : 0;

      @SuppressWarnings("unchecked")

      Function<Object[], Object>[] retrieveParameters = new Function[paramCounter];

      // There are two types of parameters, parameters that are substituted from the beginning,

      // and those that are substituted in the mainWalk() method.

      // In the case of the "extracted-value" annotation being present, create a function 

      // that returns the value after being casted to a BaseDataType.

      // For the substituted parameters that already existed, the function returns

      // the index positioned value in the params given.

      int functionCounter = 0;

                  break;

               }

               Function<Object[], Object> rp = null;

               if (next.isAnnotation("extracted-value"))

               {

                  rp = (Object[] params) -> 

                  {

                     String value = (String) next.getAnnotation("extracted-value");

                     FqlType fqlType = Enum.valueOf(FqlType.class, (String) next.getAnnotation("datatype"));

                     switch (fqlType)

                     {

                        case INTEGER:

                           return new integer(value);

                        case DECIMAL:

                           return new decimal(value);

                        case TEXT:

                           assert (value.charAt(0) == '\'');

                           assert (value.charAt(value.length() - 1) == '\'');

                           value = value.substring(1, value.length() - 1);

                           return new character(value);

                        default:

                           throw new IllegalStateException("No matching datatype for the extracted value.");

                     }

                  };

               }

               else 

               {

                  rp = (Object[] params) -> 

                  {

                     Long index = (Long) next.getAnnotation("index");

                     return params[index.intValue()];

                  };

               }

               retrieveParameters[functionCounter++] = rp;

//            case NUM_LITERAL:

//            case DEC_LITERAL:

//            case STRING:

//            case IS_NULL:

//            case NOT_NULL:

//            case BOOL_FALSE:

//               if (inline && next.isAnnotation("inlined"))

//               {

//                  // Allow null to remain at this position in the array.

//                  indices.add(null);

//               }

//               break;

      return (new ParameterDiff(retrieveParameters));

/*

** Module   : ParameterDiff.java

** Abstract : Mapping of query substitution parameters functions in an array, after where clause preprocessing.

**

** Copyright (c) 2008-2023, Golden Code Development Corporation.

**

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

** 001 ECF 20081009 @40080 Created initial version. A mapping of query substitution parameters in an array,

**                         after where clause preprocessing.

** 002 OM  20221103        New class names for FQLPreprocessor, FQLExpression, FQLBundle, and FQLCache.

** 003 DDF 20230201        Refactored ParameterIndices into ParameterDiff by replacing the Integer indices

**                         array with an array of lambdas. Instead of storing the index of the parameters

**                         from the AST node, we store a lambda that takes an array of arguments and returns 

**                         either an extracted value from the AST, or an existing value from the given array.

*/

/*

** 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;

import java.util.function.Function;

/**

 * A mapping of the active indices in an array of query substitution

 * parameters, after an HQL where clause has been preprocessed.  The HQL

 * preprocessor may inline or re-order query substitution parameters.  Thus,

 * given an array of query substitution parameters, it is necessary to provide

 * a means for a query object to organize the remaining parameters when

 * submitting a query for execution.

 * <p>

 * A query object will have the original array of parameters provided by

 * business logic, as well as an instance of {@link FQLPreprocessor}.  That

 * instance will provide an instance of this class via its {@link

 * FQLPreprocessor#getParameterDiff()} method.  To obtain the correct list

 * of parameters which corresponds with the preprocessed where clause, the

 * query iterates its original array of parameters.  For each index in that

 * array, it calls {@link #getIndex(int)} to obtain the remapped position of

 * the parameter originally at the current index.  If <code>null</code> is

 * returned, it means the parameter originally at the current index has been

 * inlined into the where clause.  A non-<code>null</code> value represents

 * the zero-based index at which the parameter can be found in the original

 * array.

 */

final class ParameterDiff

{

   /** Count of substitution parameters functions in use */

   private final int count;

   /** Array of functions for substitution parameters */

   private final Function<Object[], Object>[] substParamFunctions;

   /**

    * Constructor which sets the array of substitution parameters 

    * functions of query for the associated where clause.

    * 

    * @param   substFunctions

    *          Array of substitution parameter functions. If

    *          <code>null</code>, the associated query string has no query

    *          substitution parameters.

    */

   ParameterDiff(Function<Object[], Object>[] substFunctions)

   {

      this.substParamFunctions = substFunctions;

      int counter = 0;

      if (substParamFunctions != null)

      {

         for (int i = 0; i < substParamFunctions.length; i++)

         {

            if (substParamFunctions[i] == null)

            {

               continue;

            }

            counter++;

         }

      }

      this.count = counter;

   }

   /**

    * Get the count of query substitution parameters functions which were created for

    * the where clause preprocessing step. This is the count of the passed 

    * lambda array items to this object's constructor.

    * 

    * @return  Count of query substitution parameters functions.

    */

   int getCount()

   {

      return count;

   }

   /**

    * Given a position of a query substitution parameter function in the original 

    * array of lambdas (before the where clause preprocessing step), get the

    * lambda of that parameter in the original array.  Note that the

    * original array is not changed, only the mapping of lambdas may have

    * changed.  If the index returned matches the <code>position</code>

    * supplied, this indicates the parameter's placeholder (<code>?</code>) is

    * located at the same relative position in the where clause as before

    * preprocessing.

    * 

    * @param   position

    *          Zero-based index of the target substitution parameter function

    *          in the original array.

    * 

    * @return  New, zero-based index of the target substitution parameter function 

    *          in the original array, or <code>null</code> if the parameter was

    *          inlined during preprocessing of the where clause.

    */

   Function<Object[], Object> getIndex(int position)

   {

      return (substParamFunctions == null ? null : substParamFunctions[position]);

   }

   /**

    * Method for retrieving the substitution parameter functions.

    * 

    * @return  The substitution parameter functions, or null if

    *          no functions were assigned.

    */

   Function<Object[], Object>[] getSubstParamFunctions()

   {

      return substParamFunctions;

   }

   /**

    * Apply the substitution parameters lambdas based on the params given. The params 

    * value is used just for already substituded parameters from the where clause,

    * while the value of the subtituted parameters from the preprocessing are replaced

    * by the value of the node annotation <code>extracted-value</code>. 

    * 

    * @param   params

    *          Parameter array for lambda which selects the parameter value

    *          for substituted parameters that were not created during

    *          the preprocessing phase.

    *          The parameter array is still required for the other lambdas,

    *          but not used.

    * 

    * @return  Object representing the value of the argument.

    */

   Object[] getSubstParameters(Object[] params)

   {

      Object[] args = new Object[count];

      for (int position = 0; position < substParamFunctions.length; position++)

      {

         if (substParamFunctions[position] != null)

         {

            args[position] = substParamFunctions[position].apply(params);

         }

      }

      return args;

   }

}

**     DDF 20230201 Refactored ParameterIndices into ParameterDiff. Extracted arguments also need to be

**                  resolved. (refs: #7035)

      if (currentArgs == null)

      ParameterDiff pd = preproc.getParameterDiff();

      if (intermediate == null && pd == null)

      if (pd == null)

      {

         return intermediate;

      }

      Object[] filteredArgs = pd.getSubstParameters(intermediate);

      for (int i = 0; i < filteredArgs.length; i++)

      {

         // Substitution parameters returned also need to be resolved.

         filteredArgs[i] = resolveArg(filteredArgs[i]);

      }

//      ParameterIndices pi = preproc.getParameterIndices();

//      int len = pi.getCount();

//      Object[] filteredArgs = new Object[len];

//      for (int i = 0, count = 0; count < len; i++)

//      {

//         Integer nextIndex = pi.getIndex(i);

//         if (nextIndex == null)

//         {

//            // original substitution parameter was inlined into HQL by preprocessor;  skip it

//            continue;

//         }

//         

//         // Substitution placeholders may have been reordered if this

//         // statement was rewritten by the HQL preprocessor. Make sure

//         // we access the correct substitution parameter.

//         Object next = intermediate[nextIndex];

//         

//         filteredArgs[count++] = next;

//      }

**     DDF 20230201          Refactoring ParameterIndices into ParameterDiff and added method for retrieving 

**                           parameter values. (refs: #7035)

      ParameterDiff pi = activeBundle.getParameterDiff();

//               int k = -1;

//               if (pi == null)

//               {

//                  k = j;

//               }

//               else

//               {

//                  Integer idx = pi.getIndex(j);

//                  if (idx == null)

//                  {

//                     // original substitution parameter was inlined into HQL by preprocessor;  skip it

//                     continue;

//                  }

//                  k = idx;

//               }

               Function<Object[], Object> currentParameterFunction = pi.getIndex(j);

               Object next = currentParameterFunction.apply(values);

**     DDF 20230201          Refactoring ParameterIndices into ParameterDiff and added method for retrieving 

**                           parameter values. (refs: #7035)

               ParameterDiff pd = preproc.getParameterDiff();

               Object[] filteredArgs = pd.getSubstParameters(args);

               args = filteredArgs;

//               ParameterDiff pi = preproc.getParameterDiff();

//               int len = pi.getCount();

//               List<Object> argList = new ArrayList<>(len);

//               for (int i = 0, count = 0; count < len; i++)

//               {

//                  Integer nextIndex = pi.getIndex(i);

//                  if (nextIndex == null)

//                  {

//                     // original substitution parameter was inlined into HQL by preprocessor;

//                     // skip it.

//                     continue;

//                  }

//                  

//                  // substitution placeholders may have been reordered if this statement was

//                  // rewritten by the HQL preprocessor; make sure we access the correct

//                  // substitution parameter

//                  Object next = args[nextIndex];

//                  argList.add(next);

//                  

//                  count++;

//               }

//               args = argList.toArray();

**     DDF 20230201          Refactoring ParameterIndices into ParameterDiff and added method for retrieving 

**                           parameter values. (refs: #7035)

            ParameterDiff pd = preproc.getParameterDiff();

            Object[] filteredArgs = pd.getSubstParameters(args);

            args = filteredArgs;

//            ParameterDiff pi = preproc.getParameterDiff();

//            int len = pi.getCount();

//            List<Object> argList = new ArrayList<>(len);

//            for (int i = 0, count = 0; count < len; i++)

//            {

//               Integer nextIndex = pi.getIndex(i);

//               if (nextIndex == null)

//               {

//                  // original substitution parameter was inlined into HQL by preprocessor;

//                  // skip it.

//                  continue;

//               }

//               

//               // substitution placeholders may have been reordered if this statement was

//               // rewritten by the HQL preprocessor; make sure we access the correct

//               // substitution parameter

//               Object next = args[nextIndex];

//               argList.add(next);

//               

//               count++;

//            }

//            args = argList.toArray();