FWD » Core Development » Database

**     IAS 20221111 Added setter for the 'schemaMarshalLevel', fixed one for the 'namespaceURI'.

    * Set the current {@code SCHEMA-MARSHAL} level. Refer to {@code SM_DEFAULT}, {@code SM_NONE},

    * {@code SM_MIN}, and {@code SM_FULL} static constants for details. 

    */

   public void setSchemaMarshalLevel(int schemaMarshalLevel)

   {

      this.schemaMarshal = schemaMarshalLevel;

   }

   /**

      namespaceURI(uri.isUnknown() ? "" : uri.toJavaType());

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

               {

                  // A NO-SCHEMA-MARSHAL table cannot be used as a parameter where the receiving side

                  // does not have a pre-prepared schema

                  ErrorManager.recordOrThrowError(12323);

               }

         if (buf == null)

         {

            continue;

         }

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

** 003 IAS 20221111 Added 'xmlNodeName', 'nsURI', and 'nsPrefix' fields. 

   /** The XML namespace for this dataset. */

   private String xmlns = null;

   /** The XML prefix for this dataset. */

   private String xmlPrefix = null;

   /** The XML-NODE-NAME attribute for this dataset. */

   private String xmlNodeName = null;

      character tmp = ds.namespaceURI();

      this.xmlns = tmp.isUnknown() ? "" : tmp.toJavaType();

      tmp = ds.namespacePrefix();

      this.xmlPrefix = ds.namespacePrefix().toJavaType(); 

      tmp = ds.getXmlNodeName();

      this.xmlNodeName = ds.getXmlNodeName().toJavaType();

    * Get the XML namespace of the DATASET.

    * @return XML namespace of the DATASET

    */

   public String namespaceURI()

   {

      return xmlns;

   }

   /**

    * Get the XML prefix of the DATASET.

    * @return XML prefix of the DATASET

    */

   public String namespacePrefix()

   {

      return xmlPrefix;

   }

   /**

    * Get the XML node name of the DATASET.

    * @return XML node name of the DATASET

    */

   public String getXmlNodeName()

   {

      return xmlNodeName;

   }

   /**

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

**     IAS 20221111 Fixed support of relations' for SCHEMA-MARSHAL == NONE and issues with 

**                  processing 'schemaMarshalLevel', 'xmlNodeName', 'nsURI', and 'nsPrefix'. 

      this.originalDataSet = (DataSet)dsHandle.getResource();

      newDS.namespaceURI(wrapper.namespaceURI());

      newDS.namespacePrefix(wrapper.namespacePrefix());

      newDS.setXmlNodeName(wrapper.getXmlNodeName());

      Set<String> tablesWithoutSchema = new HashSet<>();

            if (!tableDef.isReceivedSchema())

            {

               tablesWithoutSchema.add(tableDef.getName());

               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, tableDef.getSchemaMarshalLevel());

               }

               else

               {

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

                           props, idx, xmlns, prefix, tableDef.getSchemaMarshalLevel());

               }

            if (tablesWithoutSchema.contains(relDef.getParentBuffer()) ||

                tablesWithoutSchema.contains(relDef.getChildBuffer()))

            {

               continue;

            }

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

**     IAS 20221111 Added 'xmlNodeName', 'nsURI', and 'nsPrefix' fields and fixed 

**                  'schemaMarshalLevel' support.

   /** The XML namespace for this dataset. */

   private String xmlns = null;

   /** The XML prefix for this dataset. */

   private String xmlPrefix = null;

   /** The XML-NODE-NAME attribute for this dataset. */

   private String xmlNodeName = null;

      this.xmlns = resource.namespaceURI();

      this.xmlPrefix = resource.namespacePrefix();

      this.xmlNodeName = resource.getXmlNodeName();

      this(resource);

   /**

    * Get the XML namespace of the DATASET.

    * @return XML namespace of the DATASET

    */

   public String namespaceURI()

   {

      return xmlns;

   }

   /**

    * Get the XML prefix of the DATASET.

    * @return XML prefix of the DATASET

    */

   public String namespacePrefix()

   {

      return xmlPrefix;

   }

   /**

    * Get the XML node name of the DATASET.

    * @return XML node name of the DATASET

    */

   public String getXmlNodeName()

   {

      return xmlNodeName;

   }

      writeString(out, xmlns);

      writeString(out, xmlPrefix);

      writeString(out, xmlNodeName);

      xmlns = readString(in);

      xmlPrefix = readString(in);

      xmlNodeName = readString(in);

         tw.setSchemaMarshalLevel(tdef.getSchemaMarshalLevel());

         tw.receivedSchema = tdef.receivedSchema;

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

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

**     IAS 20221111 Fixed 'schemaMarshalLevel', 'xmlNodeName', 'nsURI', and 'nsPrefix' support.

import java.util.stream.*;

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

   boolean receivedSchema = false;

   /** List of indexes' descriptors */

   private List<IndexDefinition> indexDefs = null;

    * be serialized. 

   private int schemaMarshalLevel;

         case SM_MIN:

            this.errorString = defBuff.errorString().toStringMessage();

            // no break, fall through

            character tmp = parentTable.namespaceURI(); 

            this.xmlns = tmp.isUnknown() ? "" : tmp.toJavaType(); 

            this.xmlPrefix = parentTable.namespacePrefix().toJavaType(); 

            this.xmlNodeName = parentTable.namespacePrefix().toJavaType();

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

                     collect(Collectors.toList());

    * The SCHEMA-MARSHAL level for the serialized temp-table. 

    */

   public int getSchemaMarshalLevel()

   {

      return schemaMarshalLevel;

   }

   /**

   /** 

    * 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 properties != null ? new ArrayList<>(properties) : Collections.emptyList();

      boolean writeSchema = schemaMarshalLevel != SM_NONE;

      out.writeByte(schemaMarshalLevel);

      if (writeSchema)

      {

         out.writeByte(numIndexes);

         writeString(out,indexes);

         writeList(out, indexDefs);

         writeString(out,xmlns);

         writeString(out,xmlPrefix);

      }

      // write properties

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

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

            if (writeSchema)

            {

               property.setMarshalLevel(schemaMarshalLevel);

               out.writeByte(1);

               property.writeExternal(out);

            }

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

            {

               objectProps.add(idx);

            }

      if (writeSchema)

      {

         out.writeByte(0);

      }

      writeIntSet(out, blobProps);

      writeIntSet(out, objectProps);

      schemaMarshalLevel = in.readByte(); 

      receivedSchema = schemaMarshalLevel != SM_NONE;

      if (receivedSchema)

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

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

      writeString(out, xmlNodeType);

      writeString(out, codePage);

      int flags = (serializeHidden ? 1 : 0) | (caseSensitive ? 2 : 0) | (full ? 4 : 0);

      out.writeByte(flags);

      if (!full )

      {

         return;

      }

      writeString(out, format);

      writeString(out, label);

      writeString(out, columnLabel);

      writeString(out, help);

      legacyName = readString(in);

      initial = readString(in);

      xmlNodeType = readString(in);

      codePage = readString(in);

      int flags = in.readByte();

      serializeHidden = (flags & 1) != 0;

      caseSensitive = (flags & 2) != 0;

      boolean full = (flags & 4) != 0;

      if (!full)

      {

         return;

      }

      help = readString(in);

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

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

**     IAS 20221111 Minor cleanup of the LegacyFieldInfo c'tor.

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;

            this.definedFormat = null;

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

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

**     IAS 20221104 Added structured indexes data.

**     IAS 20221111 Fixed 'schemaMarshalLevel' support.

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 properties != null ? new ArrayList<PropertyDefinition>(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