FWD » Core Development » Database

**     IAS 20221014 Fixed 'column-codepage' support.

         String cp = field.getCodePage();

         if (cp != null && !cp.trim().equals(""))

            tableField.putAnnotation("column-codepage", cp);

/*

** Module   : IndexDefinition.java

** Abstract : A container for a table index metadata.

**

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

**

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

** 001 IAS 20221104 Created initial version.

*/

/*

** 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 static com.goldencode.util.NativeTypeSerializer.*; 

import java.io.*;

import java.util.*;

import java.util.stream.*;

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

import com.goldencode.p2j.util.*;

/**

 * Container for a table index metadata. Used to send the metadata of a

 * DMO to a remote side, when remote appserver calls are involved.

 */

public class IndexDefinition

implements Externalizable

{

   /** The legacy name of this index. */

   private String legacyName;

   /**

    * Determine if the index is a primary index: the one with the "primary" annotation or, if

    * there is no such one, the first in the definition order.

    */

   private boolean effectivePrimary;

   /** Determine if the index is an unique index. */

   private boolean unique;

   /** Determine if the index is a word-index index. */

   private boolean word;

   /** Index components (fields with sorting directions). */

   private List<IndexComponentDefinition> components;

   /**

    * Default c'tor

    */

   public IndexDefinition()

   {

   }

   /**

    * Constructor 

    * @param lii

    *        ORM index info

    *        

    */

   public IndexDefinition(LegacyIndexInfo lii)

   {

      this.legacyName = lii.getLegacyName();

      this.effectivePrimary = lii.isEffectivePrimary();

      this.unique = lii.isUnique();

      this.word = lii.isWord();

      this.components = lii.indexComponents().map(lici -> new IndexComponentDefinition(lici)).

                                              collect(Collectors.toList());

   }

   /**

    * Add index to the <code>TableBuilder</code>

    * @param tb

    *        <code>TableBuilder</code> instance.

    */

   public void addTo(TempTableBuilder tb)

   {

      tb.addNewIndex(new character(legacyName),

                     new logical(unique),

                     new logical(effectivePrimary),

                     new logical(word));

      components.stream().forEach(

               c -> tb.addFieldToIndex(legacyName, 

                                       c.fieldLegacyName, 

                                       c.effectiveDescending ? "desc" : "asc"));

   }

   /**

    * Read the index definition from the specified input source.

    * 

    * @param    in

    *           The input source from which the index definition will be read.

    *

    * @throws   IOException

    *           In case of I/O errors.

    *

    * @throws  ClassNotFoundException

    *          If the class of property could not be found/loaded.

    */

   @Override

   public void readExternal(ObjectInput in) 

   throws IOException, 

          ClassNotFoundException

   {

      legacyName = readString(in);

      byte flags = in.readByte();

      effectivePrimary = (flags & 1) != 0;

      unique = (flags & 2) != 0;

      word = (flags & 4) != 0;

      components = readList(in, () -> new IndexComponentDefinition());

   }

   /**

    * Send the index definition to the specified output destination.

    * 

    * @param    out

    *           The output destination to which the index definition will be sent.

    *

    * @throws   IOException

    *           In case of I/O errors.

    */

   @Override

   public void writeExternal(ObjectOutput out) 

   throws IOException

   {

      writeString(out, legacyName);

      out.writeByte((effectivePrimary ? 1 : 0) | (unique ? 2 : 0) | (word ? 1 : 0));

      writeList(out, components);

   }

   /** A container with an index component information. */

   public static class IndexComponentDefinition

   implements Externalizable

   {

      /** The legacy name of the field participating in the index. */

      private String fieldLegacyName;

      /** Determines if this component has descending sorting. */

      private boolean effectiveDescending;

      /**

       * Default c'tor

       */

      public IndexComponentDefinition()

      {

      }

      /**

       * Constructor

       * @param lici

       *        DMO ORM index component info.

       */

      public IndexComponentDefinition(LegacyIndexComponentInfo lici)

      {

         this.fieldLegacyName = lici.fieldLegacyName;

         this.effectiveDescending = lici.effectiveDescending;

      }

      /**

       * Read the index definition from the specified input source.

       * 

       * @param    in

       *           The input source from which the index component definition will be read.

       *

       * @throws   IOException

       *           In case of I/O errors.

       *

       * @throws  ClassNotFoundException

       *          If the class of property could not be found/loaded.

       */

      @Override

      public void readExternal(ObjectInput in) 

      throws IOException, 

             ClassNotFoundException

      {

         fieldLegacyName = readString(in);

         effectiveDescending = in.readByte() != 0;

      }

      /**

       * Send the index definition to the specified output destination.

       * 

       * @param    out

       *           The output destination to which the index component definition will be sent.

       *

       * @throws   IOException

       *           In case of I/O errors.

       */

      @Override

      public void writeExternal(ObjectOutput out) 

               throws IOException

      {

         writeString(out, fieldLegacyName);

         out.writeByte(effectiveDescending ? 1 : 0);

      }

   }

}

**     IAS 20221029 Added support for missed properties.

**     IAS 20221102 Re-worked serialization for SCHEMA-MARSHAL == NONE.

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

import com.goldencode.p2j.util.*;

   /** HELP attribute of this field. */

   private String help;

   /** INITIAL attribute of this field. */

   private String initial;

   /** Flag indicating the field should not be included in serialized output. */

   private boolean serializeHidden;

   /** Flag indicating the field is case-sensitive. */

   private boolean caseSensitive;

   /** Node type of field in XML output. */

   private String xmlNodeType;

   /** Code page of the CLOB field. */

   private String codePage;

   /**

    * Create a new property definition.

    *

    * @param    prop

    *           The ORM field <code>Property</code>.

    */           

   public PropertyDefinition(Property prop)

   {

      this.name = prop.name;

      verifyType(prop._fwdType);

      this.type = prop._fwdType;

      int extent = prop.index > 0 ? 0 : prop.extent;

      this.extent = extent == 0 ? NO_EXTENT : extent;

      this.legacyName = prop.legacy;

      this.format = prop.format;

      this.label = prop.label;

      this.columnLabel = prop.columnLabel;

      this.help = prop.help;

      this.initial = prop.initial;

      this.serializeHidden = prop.serializeHidden;

      this.caseSensitive = prop.caseSensitive;

      this.xmlNodeType = prop.xmlNodeType;

      this.codePage = prop.codePage;

   }

    * Get help text of this property.

    *

    * @return help text of this property.

    */

   public String getHelp()

   {

      return help;

   }

   /**

    * Get initial value of this property.

    *

    * @return initial value of this property.

    */

   public String getInitial()

   {

      return initial;

   }

   /**

    * Get 'serialize hidden' flag of this property.

    *

    * @return 'serialize hidden' flag of this property.

    */

   public boolean isSerializeHidden()

   {

      return serializeHidden;

   }

   /**

    * Get 'case-sensitive' flag of this property.

    *

    * @return 'case-sensitive' flag of this property.

    */

   public boolean isCaseSensitive()

   {

      return caseSensitive;

   }

   /**

    * Get XML node type of this property.

    *

    * @return XML node type of this property.

    */

   public String getXmlNodeType()

   {

      return xmlNodeType;

   }

   /**

    * Get code page of this property.

    *

    * @return code page of this property.

    */

   public String getCodePage()

   {

      return codePage;

   }

   /**

      if (schemaMarshalLevel == SM_NONE)

      {

         throw new IllegalStateException("Should not be called if schemaMarshalLevel == SM_NONE");

      }

      writeString(out, name);

      writeString(out, legacyName);

      writeString(out, type == null ? null : type.getName());

      out.writeInt(extent);

      writeString(out, initial);

      out.writeByte(serializeHidden ? 1 : 0);

      out.writeByte(caseSensitive ? 1 : 0);

      writeString(out, xmlNodeType);

      writeString(out, codePage);

      out.writeByte(full ? 1 : 0);

      if (!full )

      {

         return;

      }

      writeString(out, format);

      writeString(out, label);

      writeString(out, columnLabel);

      writeString(out, help);

      legacyName = readString(in);

      initial = readString(in);

      serializeHidden = in.readByte() == 1;

      caseSensitive = in.readByte() == 1;

      xmlNodeType = readString(in);

      codePage = readString(in);

      boolean full = in.readByte() == 1;

      if (!full)

      {

         return;

      }

      help = readString(in);

**     IAS 20221018 Fixed processing of 'now' and 'today' INITIAL attribute value.

*      IAS 20222204 Added 'indexComponents()' and 'getLegacyIndexes' methods.

import java.util.stream.Stream;

    * Get stream for the indexes associated with the given temporary table.

    *

    * @param    tt

    *           Temp table object.

    * @return   stream for the indexes associated with the given temporary table.

    */

   public static Stream<TableMapper.LegacyIndexInfo> getLegacyIndexes(TempTable tt)

   {

      TempTableMapper mapper = locateTemp(tt);

      synchronized (mapper)

      {

         return mapper.legacyIndexInfo(tt);

      }

   }

   /**

       * Get stream for the indexes associated with the given temporary table.

       *

       * @param    tt

       *           Temp table object.

       * @return   stream for the indexes associated with the given temporary table.

       */

      private Stream<LegacyIndexInfo> legacyIndexInfo(TempTable tt)

      {

         LegacyTableInfo tableInfo = p2j.get(tt);

         return new ArrayList<>(tableInfo.idx).stream();

      }

      /**

                        initialValue = new character(text);

                        initialValue = new character(text);

                        initialValue = new character(text);

       * Get a stream for the index components.

       * 

       * @return iterator for the index components.

       */

      public Stream<LegacyIndexComponentInfo> indexComponents()

      {

         return Arrays.stream(components);

      }

      /**

      public final String fieldLegacyName;

      public final boolean effectiveDescending;

**     IAS 20221029 Added support for the SCHEMA-MARSHAL attribute.

**     IAS 20221102 Re-worked (de)serialization.

**     IAS 20221104 Added structured indexes data.

import static com.goldencode.p2j.persist.AbstractTempTable.*;

import java.util.stream.*;

import com.goldencode.p2j.oo.lang.*;

import com.goldencode.util.*;

   /** Flag indicating that table schema was received */  

   boolean receivedSchema = false;

   /** Table SCHEMA-MARSHAL attribute value encodes as int */ 

   private int schemaMarshalLevel;

   /** List of indexes' descriptors */

   private List<IndexDefinition> indexDefs = null;

    * Get List of indexes' descriptors.

    * @return the List of indexes' descriptors.

    */

   public List<IndexDefinition> getIndexDefs()

   {

      return indexDefs;

   }

   /**

      boolean writeSchema = schemaMarshalLevel != SM_NONE;

      out.writeByte(schemaMarshalLevel);

      if (writeSchema)

      {

         writeString(out, tableName);

         out.writeByte(tableType);

         out.writeByte(numIndexes);

         writeString(out,indexes);

         writeList(out, indexDefs);

         writeString(out,xmlns);

         writeString(out,xmlPrefix);

      }

      Set<Integer> blobProps = new HashSet<>();

      Set<Integer> objectProps = new HashSet<>();

            if (writeSchema)

            {

               property.setMarshalLevel(schemaMarshalLevel);

               out.writeByte(1);

               property.writeExternal(out);

            }

      if (writeSchema)

      {

         out.writeByte(0);

      }

      writeIntSet(out, blobProps);

      writeIntSet(out, objectProps);

            if (!blobProps.isEmpty())

            if (!objectProps.isEmpty())

                     row2[idx] = new LegacyObject((object<?>) row2[idx]);

    *          If the class of property could not be found/loaded.

   @Override

      receivedSchema = in.readByte() != SM_NONE;

      if (receivedSchema)

         tableName = readString(in);

         tableType = in.readByte();

         numIndexes = in.readByte();

         indexes = readString(in);

         indexDefs = readList(in, () -> new IndexDefinition());

         xmlns = readString(in);

         xmlPrefix = readString(in);

         properties = new ArrayList<>();

         while (in.readByte() != 0)

         {

            PropertyDefinition pd = new PropertyDefinition();

            pd.readExternal(in);

            properties.add(pd);

         }

      Set<Integer> blobProps = readIntSet(in);

      Set<Integer> objectProps = readIntSet(in);

         blobProps.stream().forEach(i -> row[i] = new blob(((MemoryBuffer) row[i]).getValue()));

         objectProps.stream().forEach(i -> {

            LegacyObject ref = (LegacyObject) row[i];

            ObjectVar<? extends _BaseObject_> v = new ObjectVar<>(ref.getType());

            v.assign(ref.restore());

            row[i] = v;

         });

   /** 

    * Check that table schema was received.

    * 

    * @return <code>true</code> if table schema was received.

    */

   public boolean isReceivedSchema() 

   {

      return receivedSchema;

   }

   /** Get encoded table SCHEMA-MARSHAL attribute value.

    * 

    * @return encoded table SCHEMA-MARSHAL attribute value.

    */

   public int getSchemaMarshalLevel()

   {

      return schemaMarshalLevel;

   }

   /** Set encoded table SCHEMA-MARSHAL attribute value.

    * 

    * @param schemaMarshalLevel 

    *        encoded table SCHEMA-MARSHAL attribute value.

    */

   public void setSchemaMarshalLevel(int schemaMarshalLevel)

   {

      this.schemaMarshalLevel = schemaMarshalLevel;

   }

      this.indexDefs = TableMapper.getLegacyIndexes(table).map(lif -> new IndexDefinition(lif)).

                                                           collect(Collectors.toList());

**     IAS 20221029 Added support for missed properties.

**     IAS 20221104 Added indexes parsing for input remote table.

    * @return   default buffer for the table

      return new TempTableBuilder().createTable(tableName, props, tableIndexes, xmlns, xmlPrefix);

      return addNewField(name, type, extent, format, initial, label, columnLabel,

               null, null, null, false, false);

   }

   /**

    * Adds a field with the specified properties to the temp-table.

    * This method is the P2J equivalent of <code>ADD-NEW-FIELD</code> method

    * of Progress 4GL.

    * <p>

    * When a parameter is set to null, it means it was not specified by the business logic.

    *

    * @param   name

    *          The name of the field to be created in the temp-table.

    * @param   type

    *          The data type of the specified field.

    * @param   extent

    *          An integer expression specifying the extent of an array.

    * @param   format

    *          The data format for the defined data type. If empty or unknown, format is

    *          replaced with default format. Null value means that format is not used in

    *          ADD-NEW-FIELD.

    * @param   initial

    *          An expression that evaluates to the initial value of the defined field.

    *          TODO: this method will probably be overloaded because of this.

    * @param   label

    *          The label of the defined field. If <code>null</code> or unknown the name

    *          parameter will be used.

    * @param   columnLabel

    *          The label of the column associated with the defined field

    * @param   help 

    * @param   xmlNodeType 

    * @param   codePage 

    * @param   serializeHidden 

    * @param   caseSensitive 

    *

    * @return  <code>true</code> on success.

    */

   public logical addNewField(character    name,

                              character    type,

                              integer      extent,

                              character    format,

                              BaseDataType initial,

                              character    label,

                              character    columnLabel,

                              character    help,

                              character    xmlNodeType,

                              character    codePage,

                              boolean      serializeHidden,

                              boolean      caseSensitive)

   {

      String helpStr = help != null ? help.getValue() : null;

      String codePageStr = codePage != null ? codePage.getValue() : null;

      String xmlNodeTypeStr = xmlNodeType != null ? xmlNodeType.getValue() : null;

                                    initial, labelStr, columnLabelStr, caseSensitive, 

                                    codePageStr, helpStr, serializeHidden, null, null,

                                    null, xmlNodeTypeStr, false, 0, 0);

    * Create a temp-table with the specified definition.

    * 

    * @param    tableName

    *           The table name.

    * @param    props

    *           The property definitions.

    * @param    tableIndexes

    *           The index definitions.

    * @param    xmlns

    *           The XML namespace.

    * @param    xmlPrefix

    *           The XML prefix.

    * @return   default buffer for the table

    */

   public BufferImpl createTable(String tableName,

                                 Iterator<PropertyDefinition> props,

                                 String tableIndexes, 

                                 String xmlns,

                                 String xmlPrefix)

   {

      return  createTable(tableName, props, 

                          () -> parseIndexString(tableIndexes), xmlns, xmlPrefix);

   }

   /**

    * Create a temp-table with the specified definition.

    * 

    * @param    tableName

    *           The table name.

    * @param    props

    *           The property definitions.

    * @param    indexProvider

    *           indexes' provider.

    * @param    xmlns

    *           The XML namespace.

    * @param    xmlPrefix

    *           The XML prefix.

    * @return   default buffer for the table

    */

   public BufferImpl createTable(String tableName,

                                 Iterator<PropertyDefinition> props,

                                 Runnable indexProvider, 

                                 String xmlns,

                                 String xmlPrefix)

   {

      props.forEachRemaining(this::addNewField);

      indexProvider.run();

      tempTablePrepare(tableName);

      BufferImpl buff = (BufferImpl) defaultBufferHandle.getResource();

      if (xmlns != null)

      {

         buff.namespaceURI(xmlns);

      }

      if (xmlPrefix != null)

      {

         buff.namespacePrefix(xmlPrefix);

      }

      return buff;

   }

   /**

      List<IndexDefinition> indexDefs = tableWrapper.getIndexDefs();

      if (indexDefs != null)

      {

         createTable(tableWrapper.getTableName(), 

                  tableWrapper.propertyIterator(), 

                  () -> indexDefs.stream().forEach(idx -> idx.addTo(this)), 

                  tableWrapper.getXmlns(), 

                  tableWrapper.getXmlPrefix());

      }

      else

      {

         createTable(tableWrapper.getTableName(), 

                  tableWrapper.propertyIterator(), 

                  tableWrapper.getIndexes(), 

                  tableWrapper.getXmlns(), 

                  tableWrapper.getXmlPrefix());

      }

                  new character(propertyDefinition.getInitial()),

                  new character(propertyDefinition.getColumnLabel()),

                  new character(propertyDefinition.getHelp()),

                  new character(propertyDefinition.getXmlNodeType()),

                  new character(propertyDefinition.getCodePage()),

                  propertyDefinition.isSerializeHidden(),

                  propertyDefinition.isCaseSensitive());

    * Add indexes based on multiIxCols string.

    * 

    * @param tableIndexes

    *        multiIxCols string to be parsed.

    */

   private void parseIndexString(String tableIndexes)

   {

      if (tableIndexes != null)

      {

         String[] indexes = tableIndexes.split("\\.");

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

         {

            String indexDef = indexes[i];

            if (indexDef.isEmpty())

            {

               continue;

            }

            String[] compAndName = indexDef.split(":");

            String typeAndComps = compAndName[0];

            String idxName = compAndName[1];

            String[] comps = typeAndComps.split(",");

            boolean unique = (i != 0) || "1".equals(comps[0]);

            boolean primary = (i == 0) && ("1".equals(comps[0]) || "0".equals(comps[0]));

            addNewIndex(new character(idxName),

                            new logical(unique),

                            new logical(primary));

            for (int j = (primary ? 1 : 0); j < comps.length; j++)

            {

               addFieldToIndex(idxName, comps[j]);

            }

         }

      }

   }

   /**

**     IAS 20221029 Re-worked 'init' method.

      Map<Integer, PropertyDefinition> mprops = new TreeMap<>();

      iter.forEachRemaining(prop -> mprops.put(dmoPropIndex.get(prop.name), new PropertyDefinition(prop)));

      List<PropertyDefinition> lprops = new ArrayList<>(mprops.values());

**     IAS 20221102          Added error reporting for SCHEMA-MARSHAL == NONE.

**     IAS 20221103          Fixed support for a binded table parameter.

            else if (bind)

            {

               RecordBuffer rb = ((BufferReference) dstDMO).buffer();

               DmoMeta meta = rb.getDmoInfo();

               Iterator<Property> props = meta.getFields(false);

               List<PropertyDefinition> pdl = new ArrayList<>();

               props.forEachRemaining(p -> pdl.add(new PropertyDefinition(p)));

               src.getResultSet().setProperties(pdl);

            }

            if (!resultSet.isReceivedSchema())

            {

               ErrorManager.recordOrThrowError(12323);

            }

**     IAS 20221018 Fixed processing of 'now' and 'today' INITIAL attribute value.

                           init = "today".equalsIgnoreCase(p.initial) ? new character(p.initial) : new date(p.initial);

                              init =  new character(p.initial);

                              init = new character(p.initial);

**     IAS 20221018 Fixed processing of 'now' and 'today' INITIAL attribute value.

                           if (fwdType == date.class && "today".equalsIgnoreCase(defaultStrVal))

                           {

                                defVal = new character("today"); 

                           }

                           else if ((fwdType == datetime.class || fwdType == datetimetz.class) &&

                                     "now".equalsIgnoreCase(defaultStrVal))

                           {

                              defVal = new character("now"); 

                           }

                           else

                           {

                              try

                              {

                                 Constructor<? extends BaseDataType> ctor = 

                                    (Constructor<? extends BaseDataType>) fwdType.getConstructor(String.class);

                                 defVal = ctor.newInstance(defaultStrVal);

                              }

                              catch (NoSuchMethodException | IllegalAccessException | 

                                     InstantiationException | InvocationTargetException e)

                              {

                                 ErrorManager.recordOrShowError(13143, defaultStrVal, fieldName);

                                 // Unable to set initial value '<value>' from XML Schema for field '<field>'.

                                 return false;

                              }

**     IAS 20221029 Fixed TableParameter processing.

                  int schemaMarshalLevel = tableParam.getSchemaMarshalLevel();