FWD » Core Development » Database

**     IAS 20221108 Fixed support for SCHEMA-MARSHAL == NONE.

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

               if (dsSrc.isRemoteParameter()  && !wrapper.isReceivedSchema())

               {

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

                  DmoMeta meta = rb.getDmoInfo();

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

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

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

                  wrapper.setProperties(pdl);

               }

               // check if all tables contain schema.

               if (!dsParam.getDatasetWrapper().getTableDefs().stream().

                        allMatch(DsTableDefinition::isReceivedSchema))

               {

                  ErrorManager.recordOrThrowError(12323);

               }

         if (buf == null)

         {

            continue;

         }

**     IAS 20221108 Fixed support for SCHEMA-MARSHAL == NONE. Re-worked indexes (de)serialization.

            if (!tableDef.isReceivedSchema())

            {

               continue;

            }

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

               TempTableBuilder ttb = new TempTableBuilder(); 

               if (indexDefs != null)

               {

                  buffs[k] = ttb.createRemoteTable(tableDef.getName(), 

                           props, () -> indexDefs.stream().forEach(ix -> ix.addTo(ttb)), 

                           xmlns, prefix);

               }

               else

               {

                  buffs[k] = ttb.createRemoteTable(tableDef.getName(), 

                           props, idx, xmlns, prefix);

               }

**     IAS 20221108 Fixed support for SCHEMA-MARSHAL == NONE.

         tw.receivedSchema = tdef.receivedSchema;

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

**     IAS 20221108 Fixed support for SCHEMA-MARSHAL == NONE. Re-worked (de)serialization.

import java.util.stream.*;

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

   boolean receivedSchema = false;

   /** List of indexes' descriptors */

   private List<IndexDefinition> indexDefs = null;

            this.indexes = TableMapper.getLegacyIndexInfo(parentTable);

            this.numIndexes = this.indexes.split("\\.").length;

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

                     collect(Collectors.toList());

   /** 

    * Check that table schema was received.

    * 

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

    */

   public boolean isReceivedSchema() 

   {

      return receivedSchema;

   }

    * Get List of indexes' descriptors.

    * @return the List of indexes' descriptors.

    */

   public List<IndexDefinition> getIndexDefs()

   {

      return indexDefs;

   }

   /**

      return new ArrayList<>(properties != null ? properties : Collections.emptyList());

      boolean writeSchema = schemaMarshalLevel != SM_NONE;

      out.writeByte(schemaMarshalLevel);

      if (writeSchema)

      {

         writeList(out, indexDefs);

      }

      // write properties

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

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

            if (writeSchema)

            {

            }

            else if (object.class.isAssignableFrom(property.getType()))

               {

               objectProps.add(idx);

            }

      if (writeSchema)

      {

      }

      writeIntSet(out, blobProps);

      writeIntSet(out, objectProps);

      receivedSchema = in.readByte() != SM_NONE;

      if (receivedSchema)

      {

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

         while (in.readByte() != 0)

      Set<Integer> blobProps = readIntSet(in);

      Set<Integer> objectProps = readIntSet(in);

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

   }

   /**

      return new ArrayList<PropertyDefinition>(

               properties != null ? properties : Collections.emptyList());

      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.

**     IAS 20221108 Replaced static 'createRemoteTable' with a regular one.

    * @return   default buffer for the table

   public BufferImpl createRemoteTable(String tableName,

      return createTable(tableName, props, 

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

   }

   /**

    * Create a temp-table with the specified definition, as received from a remote side.

    * 

    * @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 createRemoteTable(String tableName,

                                              Iterator<PropertyDefinition> props,

                                              Runnable indexProvider, 

                                              String xmlns,

                                              String xmlPrefix)

   {

      return createTable(tableName, props, indexProvider, 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,