marshal1.diff

src/com/goldencode/p2j/persist/DynamicTablesHelper.java 2022-11-02 07:54:50 +0000
79	79	** OM 20220914 Use MAX-WIDTH to generate custom sized varchar columns.
80	80	** IAS 20221006 Added RAW type to the switch in the 'generateSchemaAst'.
81	81	** IAS 20221013 Fixed setting of "serialize-name" and "serialize-hidden annotations".
	82	** IAS 20221014 Fixed 'column-codepage' support.
82	83	*/
83	84
84	85	/*
...	...
831	832	{
832	833	tableField.putAnnotation("col_lab", field.getColumnLabel());
833	834	}
834
835		if (field.getCodePage() != null)
	835	String cp = field.getCodePage();
	836	if (cp != null && !cp.trim().equals(""))
836	837	{
837		tableField.putAnnotation("codePage", field.getCodePage());
	838	tableField.putAnnotation("column-codepage", cp);
838	839	}
839	840
840	841	if (field.isSerializeHidden())

     **     SVL 20201030 Added format, label and columnLabel fields.
     **     OM  20201120 Added SCHEMA-MARSHAL implementation.
     **     CA  20220909 Always marshal the schema, otherwise the remote side will not be able to rebuild the table.
     **     IAS 20221029 Added support for missed properties.
     **     IAS 20221102 Re-worked serialization for SCHEMA-MARSHAL == NONE.
     */
     /*
-...
     import java.io.*;
     import java.util.*;
     import com.goldencode.p2j.persist.orm.*;
     import com.goldencode.p2j.util.*;
     import static com.goldencode.p2j.persist.AbstractTempTable.*;
     import static com.goldencode.util.NativeTypeSerializer.*;
-...
        /** The column label of this property. */
        private String columnLabel;
        /** 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;
        /**
         * The SCHEMA-MARSHAL level for the parent  temp-table. It is never {@code SM_DEFAULT} when object is to
         * be serialized. Always {@code SM_DEFAULT} for a read object.
-...
           this.label = label;
           this.columnLabel = columnLabel;
+       }
        /**
         * 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 the type of this property.
+        *
-...
+       }
        /**
         * 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;
+       }
        /**
         * Send the property definition to the specified output destination.
+        *
         * @param    out
-...
        public final void writeExternal(ObjectOutput out)
        throws IOException
+       {
           if (schemaMarshalLevel == SM_NONE)
+          {
              throw new IllegalStateException("Should not be called if schemaMarshalLevel == SM_NONE");
+          }
           boolean full = schemaMarshalLevel == SM_FULL || schemaMarshalLevel == SM_DEFAULT;
           // we can't omit the schema-related field information, as otherwise the remote side will not be able to
           // recreate the temp-table.
           boolean none = false; // schemaMarshalLevel == SM_NONE;
           writeString(out, none ? null : name);
           writeString(out, (type == null || none) ? null : type.getName());
           out.writeInt(none ? 0 : extent);
           writeString(out, none ? null : legacyName);
           writeString(out, full ? format : null);
           writeString(out, full ? label : null);
           writeString(out, full ? columnLabel : null);
           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);
+       }
        /**
-...
               ClassNotFoundException
+       {
           name = readString(in);
           legacyName = readString(in);
           String tn = readString(in);
           type = (tn == null) ? null : Class.forName(tn);
           extent = in.readInt();
           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;
+          }
           format = readString(in);
           label = readString(in);
           columnLabel = readString(in);
           help = readString(in);
+       }
        /**

src/com/goldencode/p2j/persist/TableMapper.java 2022-11-01 07:17:53 +0000
102	102	** CA 20220601 getIndexFieldNames must return lowercased legacy names.
103	103	** OM 20220914 Added MAX-WIDTH support for CHARACTER fields.
104	104	** IAS 20221006 Added 'definedFormat' and 'definedLabel'.
	105	** IAS 20221018 Fixed processing of 'now' and 'today' INITIAL attribute value.
105	106	** CA 20221031 Added JMX instrumentation for 'mapTemporaryTable'.
106	107	*/
107	108
...	...
2882	2883	{
2883	2884	if ("today".equalsIgnoreCase(text))
2884	2885	{
2885		initialValue = date.today();
	2886	initialValue = new character(text);
2886	2887	}
2887	2888	else
2888	2889	{
...	...
2893	2894	{
2894	2895	if ("now".equalsIgnoreCase(text))
2895	2896	{
2896		initialValue = datetime.now();
	2897	initialValue = new character(text);
2897	2898	}
2898	2899	else if (text.toUpperCase().indexOf('T') > 0)
2899	2900	{
...	...
2910	2911	{
2911	2912	if ("now".equalsIgnoreCase(text))
2912	2913	{
2913		initialValue = datetimetz.now();
	2914	initialValue = new character(text);
2914	2915	}
2915	2916	else if (text.toUpperCase().indexOf('T') > 0)
2916	2917	{

     **                  (so that relations, schema, etc is done on the server-side).
     **     CA  20220428 Allow null peerDef at setPeerDef.
     **     CA  20220602 Added basic support for transport of object instances over appserver call.
     **     IAS 20221029 Added support for the SCHEMA-MARSHAL attribute.
     **     IAS 20221102 Re-worked (de)serialization.
     */
     /*
-...
     package com.goldencode.p2j.persist;
     import static com.goldencode.util.NativeTypeSerializer.*;
     import static com.goldencode.p2j.persist.AbstractTempTable.*;
     import java.io.*;
     import java.lang.reflect.Array;
     import java.util.*;
     import com.goldencode.p2j.oo.lang.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.util.*;
     /**
      * Any {@link TableResultSet} instance will be wrapped in a {@link TableWrapper} instance before
-...
        /** Table name. */
        private String tableName;
        /** Flag indicating that table schema was received */
        boolean receivedSchema = false;
        /** Table SCHEMA-MARSHAL attribute value encodes as int */
        private int schemaMarshalLevel;
        /**
         * Determines if this wrapper wraps data from a TABLE-HANDLE parameter. Necessary because of
-...
              return;
+          }
           writeString(out, tableName);
           out.writeByte(tableType);
           out.writeByte(numIndexes);
           writeString(out,indexes);
           writeString(out,xmlns);
           writeString(out,xmlPrefix);
           boolean writeSchema = schemaMarshalLevel != SM_NONE;
           out.writeByte(schemaMarshalLevel);
           if (writeSchema)
+          {
              writeString(out, tableName);
              out.writeByte(tableType);
              out.writeByte(numIndexes);
              writeString(out,indexes);
              writeString(out,xmlns);
              writeString(out,xmlPrefix);
+          }
           // write properties
           Set<Integer> blobProps = null;
           Set<Integer> objectProps = null;
           Set<Integer> blobProps = new HashSet<>();
           Set<Integer> objectProps = new HashSet<>();
           if (resultSet != null)
+          {
              int idx = 0;
              while (resultSet.hasMoreProperties())
+             {
                 PropertyDefinition property = resultSet.nextProperty();
                 out.writeByte(1);
                 property.writeExternal(out);
                 if (writeSchema)
+                {
                    property.setMarshalLevel(schemaMarshalLevel);
                    out.writeByte(1);
                    property.writeExternal(out);
+                }
                 if (property.getType() == blob.class)
+                {
                    if (blobProps == null)
+                   {
                       blobProps = new HashSet<>();
+                   }
                    blobProps.add(idx);
+                }
                 else if (object.class.isAssignableFrom(property.getType()))
+                {
                    if (objectProps == null)
+                   {
                       objectProps = new HashSet<>();
+                   }
                    objectProps.add(idx);
+                }
                 idx = idx + 1;
+             }
+          }
           out.writeByte(0);
           if (writeSchema)
+          {
              out.writeByte(0);
+          }
           writeIntSet(out, blobProps);
           writeIntSet(out, objectProps);
           // write data
           if (resultSet != null)
+          {
              while (resultSet.hasMoreRows())
+             {
                 Object[] row = resultSet.nextRow();
                 if (blobProps != null)
                 if (!blobProps.isEmpty())
+                {
                    Object[] row2 = new Object[row.length];
                    System.arraycopy(row, 0, row2, 0, row2.length);
-...
                    row = row2;
+                }
                 if (objectProps != null)
                 if (!objectProps.isEmpty())
+                {
                    Object[] row2 = new Object[row.length];
                    System.arraycopy(row, 0, row2, 0, row2.length);
-...
+                   {
                       if (row2[idx] instanceof object)
+                      {
                          row2[idx] = new LegacyObject((object) row2[idx]);
                          row2[idx] = new LegacyObject((object<?>) row2[idx]);
+                      }
+                   }
-...
         * @throws   IOException
         *           In case of I/O errors.
         * @throws   ClassNotFoundException
         *          If the class of property could not be found/loaded.
         */
        @Override
        public final void readExternal(ObjectInput in)
        throws IOException,
               ClassNotFoundException
-...
              return;
+          }
           tableName = readString(in);
           tableType = in.readByte();
           numIndexes = in.readByte();
           indexes = readString(in);
           xmlns = readString(in);
           xmlPrefix = readString(in);
           Set<Integer> blobProps = null;
           Set<Integer> objectProps = null;
           int idx = 0;
           properties = new ArrayList<>();
           do
           receivedSchema = in.readByte() != SM_NONE;
           if (receivedSchema)
+          {
              if (in.readByte() == 0)
+             {
                 break;
+             }
              PropertyDefinition pd = new PropertyDefinition();
              pd.readExternal(in);
              properties.add(pd);
              if (pd.getType() == blob.class)
+             {
                 if (blobProps == null)
+                {
                    blobProps = new HashSet<>();
+                }
                 blobProps.add(idx);
+             }
              if (object.class.isAssignableFrom(pd.getType()))
+             {
                 if (objectProps == null)
+                {
                    objectProps = new HashSet<>();
+                }
                 objectProps.add(idx);
+             }
              idx = idx + 1;
              tableName = readString(in);
              tableType = in.readByte();
              numIndexes = in.readByte();
              indexes = readString(in);
              xmlns = readString(in);
              xmlPrefix = readString(in);
              properties = new ArrayList<>();
              while (in.readByte() != 0)
+             {
                 PropertyDefinition pd = new PropertyDefinition();
                 pd.readExternal(in);
                 properties.add(pd);
+             }
+          }
           while (true);
           Set<Integer> blobProps = readIntSet(in);
           Set<Integer> objectProps = readIntSet(in);
           // read data
           rows = new ArrayList<>();
-...
              Object[] row = (Object[]) next;
              rows.add(row);
              if (blobProps != null)
+             {
                 for (Integer i : blobProps)
+                {
                    row[i] = new blob(((MemoryBuffer) row[i]).getValue());
+                }
+             }
              if (objectProps != null)
+             {
                 for (Integer i : objectProps)
+                {
                    LegacyObject ref = (LegacyObject) row[i];
                    ObjectVar v = new ObjectVar(ref.getType());
                    v.assign(ref.restore());
                    row[i] = v;
+                }
+             }
              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;
              });
              next = in.readObject();
              rowsMeta.add((Object[]) next);
-...
+          }
+       }
        /**
         * Check that table schema was received.
+        *
         * @return <code>true</code> if table schema was received.
         */
        public boolean isReceivedSchema()
+       {
           return receivedSchema;
+       }
        /**
         * Determines if this wrapper wraps data from a TABLE-HANDLE parameter.
+        *
-...
           this.tableHandle = tableHandle;
+       }
        /** 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;
+       }
        /**
         * Initialize this wrapper with the info from the given temp-table.
+        *

     **     OM  20220914 Added MAX-WIDTH support for CHARACTER fields.
     **     IAS 20221003 Fixed default value of the PRIMARY attribute
     **     IAS 20221014 Added COMHANDLE to the 'datatypesMatchLen' map
     **     IAS 20221029 Added support for missed properties.
     */
     /*
-...
                                   character    label,
                                   character    columnLabel)
+       {
           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)
+       {
           addFunctionCalled = true;
           if (_prepared())
-...
           String labelStr = label != null ? label.getValue() : null;
           String columnLabelStr = columnLabel != null ? columnLabel.getValue() : null;
           String helpStr = help != null ? help.getValue() : null;
           String codePageStr = codePage != null ? codePage.getValue() : null;
           String xmlNodeTypeStr = xmlNodeType != null ? xmlNodeType.getValue() : null;
           // Note: case-sensitivity and CLOB code page cannot be specified using P4GL ADD-NEW-FIELD method
           long ext = extent == null || extent.getValue() == 1 ? 0 : extent.getValue();
           P2JField field = new P2JField(fieldName, parmType, ext, formatStr,
                                         initial, labelStr, columnLabelStr, false, null, null, false, null, null,
                                         null, null, false, 0, 0);
                                         initial, labelStr, columnLabelStr, caseSensitive,
                                         codePageStr, helpStr, serializeHidden, null, null,
                                         null, xmlNodeTypeStr, false, 0, 0);
           addField(field);
           return new logical(true);
+       }
-...
              PropertyDefinition propertyDefinition = iter.next();
              addNewField(propertyDefinition);
+          }
           this.namespaceURI(tableWrapper.getXmlns());
           this.namespacePrefix(tableWrapper.getXmlPrefix());
           tempTablePrepare(tableWrapper.getTableName());
           TemporaryBuffer.insertAllRows(tableWrapper,
                                         (Temporary) defaultBufferHandle().getResource(),
-...
                       new character(dataType),
                       extent,
                       new character(propertyDefinition.getFormat()),
                       null,
                       new character(propertyDefinition.getInitial()),
                       new character(propertyDefinition.getLabel()),
                       new character(propertyDefinition.getColumnLabel()));
                       new character(propertyDefinition.getColumnLabel()),
                       new character(propertyDefinition.getHelp()),
                       new character(propertyDefinition.getXmlNodeType()),
                       new character(propertyDefinition.getCodePage()),
                       propertyDefinition.isSerializeHidden(),
                       propertyDefinition.isCaseSensitive());
+       }
        /**

     **     SVL 20210701 Added clearRows.
     **     CA  20221006 Do not access tableHandle() in the FWD runtime, get the TempTable instance directly.
     **                  Refs #6826
     **     IAS 20221029 Re-worked 'init' method.
     */
     /*
-...
         * @param    append
         *           Flag indicating this table is sent in APPEND mode.
+        *
         * @throws   ClassNotFoundException
         *           If the type of a property can not be resolved to a class.
         */
        public TempTableResultSet(Temporary dmo, boolean input, boolean output, boolean append)
     //   throws ClassNotFoundException
+       {
           this(dmo, input, output, append, true);
+       }
-...
         * TODO: improve this (i.e. use an open cursor or some other alternative to not read the data
         *       in memory)
+        *
         * @throws   ClassNotFoundException
         *           If the type of a property can not be resolved to a class.
         */
        private void init(boolean copyRows)
     //   throws ClassNotFoundException
+       {
           TemporaryBuffer buffer = (TemporaryBuffer) ((BufferReference) dmo).buffer();
-...
+          {
              dmoPropIndex.put(dmoProps[i], i);
+          }
           PropertyDefinition[] props = new PropertyDefinition[dmoProps.length];
           Iterator<Property> iter = dmoInfo.getFields(false); // skip properties that are not accessible via the DMO's API.
           while (iter.hasNext())
+          {
              Property prop = iter.next();
              // the Properties whose extent fields were denormalized are treated as simple ones
              int extent = prop.index > 0 ? 0 : prop.extent;
              if (extent == 0)
+             {
                 props[dmoPropIndex.get(prop.name)] =
                    new PropertyDefinition(prop.name,
                                           prop._fwdType,
                                           prop.legacy,
                                           prop.format,
                                           prop.label,
                                           prop.columnLabel);
+             }
              else
+             {
                 props[dmoPropIndex.get(prop.name)] =
                    new PropertyDefinition(prop.name,
                                           prop._fwdType,
                                           extent,
                                           prop.legacy,
                                           prop.format,
                                           prop.label,
                                           prop.columnLabel);
+             }
+          }
           java.util.List<PropertyDefinition> lprops = new ArrayList<>();
           for (int i = 0; i < props.length; i++)
+          {
              if (props[i] != null)
+             {
                 lprops.add(props[i]);
+             }
+          }
           Iterable<Property> iter = () -> dmoInfo.getFields(false); // skip properties that are not accessible via the DMO's API.
           Map<Integer, PropertyDefinition> mprops = new TreeMap<>();
           for (Property prop: iter)
+          {
              mprops.put(dmoPropIndex.get(prop.name), new PropertyDefinition(prop));
+          }
           List<PropertyDefinition> lprops = new ArrayList<>(mprops.values());
           if (copyRows)
+          {

     **                           they are not.
     **     OM  20221027          Use Dialect API to create and drop sequences.
     **     CA  20221031          Added JMX instrumentation for TABLE[-HANDLE] parameter processing.
     **     IAS 20221102          Added error reporting for SCHEMA-MARSHAL == NONE.
     **     OM  20221103          New class names for FQLPreprocessor, FQLExpression, FQLBundle, and FQLCache.
     **     IAS 20221103          Fixed support for a binded table parameter.
     */
     /*
-...
                       src.setTable(dstDMO);
+                   }
+                }
                 else if (bind)
+                {
                    RecordBuffer rb = ((BufferReference) dstDMO).buffer();
                    DmoMeta meta = rb.getDmoInfo();
                    Iterable<Property> props = () -> meta.getFields(false);
                    List<PropertyDefinition> pdl = new ArrayList<>();
                    for ( Property p: props)
+                   {
                       pdl.add(new PropertyDefinition(p));
+                   }
                    src.getResultSet().setProperties(pdl);
+                }
                 else
+                {
                    // TODO: remote table-handle param ??
-...
              else
+             {
                 TableWrapper resultSet = src.getResultSet();
                 if (!resultSet.isReceivedSchema())
+                {
                    ErrorManager.recordOrThrowError(12323);
+                }
                 if (resultSet != null && resultSet.isValid() && resultSet.getTableName() != null)
+                {
                    TempTableBuilder builder = new TempTableBuilder();

src/com/goldencode/p2j/persist/orm/DmoMeta.java 2022-10-18 08:44:59 +0000
39	39	** to a better suited name.
40	40	** OM 20220706 The objects returned by getDatabaseIndexes() carry the legacy names, too.
41	41	** OM 20220914 Use MAX-WIDTH to generate custom sized varchar columns.
	42	** IAS 20221018 Fixed processing of 'now' and 'today' INITIAL attribute value.
42	43	*/
43	44
44	45	/*
...	...
1591	1592	{
1592	1593	if (bdtType == date.class)
1593	1594	{
1594		init = "today".equalsIgnoreCase(p.initial) ? date.today() : new date(p.initial);
	1595	init = "today".equalsIgnoreCase(p.initial) ? new character(p.initial) : new date(p.initial);
1595	1596	}
1596	1597	else if (bdtType == datetime.class)
1597	1598	{
1598	1599	if ("now".equalsIgnoreCase(p.initial))
1599	1600	{
1600		init = datetime.now();
	1601	init = new character(p.initial);
1601	1602	}
1602	1603	else if (p.initial.toUpperCase().indexOf('T') > 0)
1603	1604	{
...	...
1614	1615	{
1615	1616	if ("now".equalsIgnoreCase(p.initial))
1616	1617	{
1617		init = datetimetz.now();
	1618	init = new character(p.initial);
1618	1619	}
1619	1620	else if (p.initial.toUpperCase().indexOf('T') > 0)
1620	1621	{

     **     OM  20220914 Use MAX-WIDTH to generate custom sized varchar columns.
     **     IAS 20220926 Fixed READ-XMLSCHEMA support.
     **     IAS 20221014 More fixes to READ-XMLSCHEMA support.
     **     IAS 20221018 Fixed processing of 'now' and 'today' INITIAL attribute value.
     */
     /*
-...
                                   // Unable to set initial value '<value>' from XML Schema for field '<field>'.
                                   return false;
+                               }
                                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;
                                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;
+                                  }
+                               }
+                            }

     **     CA  20220428 Fixed memptr, extent, table arguments when the request is remote.
     **     CA  20220602 Added basic support for transport of object instances over appserver call.
     **     CA  20220912 If a dataset from the call has no buffers added to it, set it to unknown.
     **     IAS 20221029 Fixed TableParameter processing.
     */
     /*
-...
                       boolean input = (mode == 'I' || mode == 'U');
                       boolean output = (mode == 'O' || mode == 'U');
                       int schemaMarshalLevel = tableParam.getSchemaMarshalLevel();
     //               try
     //               {
                       arg = new TableWrapper(new TempTableResultSet(tempDMO, input, output, append, input));
                       String tableName = ((BufferImpl) tempDMO).buffer().getDmoInfo().legacyTable;
                       ((TableWrapper) arg).setTableName(tableName);
     //               }
     //               catch (ClassNotFoundException e)
     //               {
     //                  String err = String.format("Could not process temp DMO %s as a parameter!",
     //                                              tempDMO.getClass().getName());
     //
     //                  throw new IllegalArgumentException(err, e);
     //               }
                       ((TableWrapper) arg).setSchemaMarshalLevel(schemaMarshalLevel);
                       handle tableHandle = ((Buffer) tempDMO).tableHandle();
                       if (tableHandle._isValid())
+                      {
                          ((TableWrapper) arg).init((TempTable) tableHandle.getResource());
+                      }
                       try
+                      {

     **                           with namesakes in DMO. See #6694.
     **     IAS 20221003          Fixed error message for error 3131
     **     IAS 20221006          Reverted error message for error 3131 change.
     **     IAS 20221102          Added error 12323 support.
     */
     /*
-...
              case 12301: msg = "Source and target are the same table in temp-table copy operation for %1"; break;     // dataset-copy (itself)
              case 12303: msg = "COPY-TEMP-TABLE requires %1 and %2 columns to match exactly unless the fourth loose-mode parameter is passed as TRUE"; break; // dataset-copy (table structure not matching)
              case 12310: msg = "Caller and called dataset parameters have different number of members"; break;
              case 12323: msg = "A NO-SCHEMA-MARSHAL table cannot be used as a parameter where the receiving side does not have a pre-prepared schema"; break;
              case 12344: msg = "Cannot turn on TRACKING-CHANGES for a static temp-table unless DEFINED with a BEFORE-TABLE phrase"; break;
              case 12352: msg = "Argument %1 to query callback method must be a valid query event name such as OFF-END"; break;
              case 12355: msg = "TRACKING-CHANGES may not be turned on for a non-dataset temp-table"; break;

     **                  INPUT-OUTPUT mode, and the DATASET-HANDLE, DATASET, TABLE-HANDLE or TABLE versions.
     **     CA  20220727 Fixed OO dataset/table parameters (at the method definition and method call) when there is
     **                  an APPEND option.
     **     IAS 20221029 Added SCHEMA-MARSHAL attribute support.
     */
     /*
-...
        /** {@code true} if the parameter mode is OUTPUT or INPUT-OUTPUT. */
        private boolean output = false;
        /** Table SCHEMA-MARSHAL attribute value encodes as int */
        private int schemaMarshalLevel;
        /** Flag indicating this is a TABLE-HANDLE argument. */
        private boolean isTableHandle = false;
-...
           this.options     = options;
           this.input       = input;
           this.output      = output;
           this.schemaMarshalLevel = ((AbstractTempTable)this.tableHandle.unwrapTempTable()).
                                            getSchemaMarshalLevel();
+       }
        /**
-...
           return parameterIndex;
+       }
        /** Get encoded table SCHEMA-MARSHAL attribute value.
+        *
         * @return encoded table SCHEMA-MARSHAL attribute value.
         */
        public int getSchemaMarshalLevel()
+       {
           return schemaMarshalLevel;
+       }
        /**
         * Set 1-based index of the table parameter (in declaration of the function).
+        *

Project

General

Profile

FWD » Core Development » Database