FWD » Core Development » Database

** Module   : java_dmo.xml

** Abstract : walks data model AST and generates Java AST for each class node

**

**

** _#_ _I_ __Date__ _______________________________________Description_______________________________________

** 001 OM  20220707 First commit with basic implementation.

-->

<!--

      <rule>typeMapping.put("logical",     "Boolean")</rule>

      <rule>typeMapping.put("object",      "Long")</rule>

      <rule>typeMapping.put("raw",         "byte[]")</rule>

      <rule>typeMapping.put("rowid",       "Long")</rule>

      <rule>importPacks = create("java.util.HashSet")</rule>

**                           if this is specified in cfg file.

**     SP  20250324          Removed support for custom denormalized extents.

** 108 SP  20250714          Fixed column collision check for expanded extent fields.

-->

<!--

      <rule>dataTypes.put(prog.field_int64,       'int64'                   )</rule>

      <rule>dataTypes.put(prog.field_logical,     'logical'                 )</rule>

      <rule>dataTypes.put(prog.field_raw,         'raw'                     )</rule>

      <rule>dataTypes.put(prog.field_rowid,       'rowid'                   )</rule>

      <rule>dataTypes.put(prog.field_class,       'object&lt;? extends _BaseObject_&gt;')</rule>

                  <rule>

                     type == prog.field_int or

                     type == prog.field_date or

                     type == prog.field_handle

                     <action>sqlWidth = #(long) 4</action>

                  </rule>

                     <!-- TODO: determine the proper length -->

                     <action>sqlWidth = #(long) -1</action>

                  </rule>

                     <action>sqlWidth = #(long) 8</action>

                  </rule>

                  <rule>type == prog.field_char

      OrmDataSetParam,

      /** Instrumentation for <code>DataSet.createDynamicDataSet</code>. */

      OrmDynamicDataSetParam,

      /** Instrumentation for <code>OutputTableCopier.finished</code> */

      OutputTableCopier,

   public static enum Counter

   implements OptionalCounter

   {

      /** Incomning network traffic */

      NetworkReads,

      /** Outgoing network traffic */

    * Get the record ID of the current buffer's current record, if any.  P2J

    * implementation of the RECID function.

    * <p>

    *

    * @return  Record ID of the underlying data record. If no record currently

    *          backs the buffer associated with <code>dmo</code>, a recid

    *          initialized as unknown value is returned.

    */

   public recid recordID()

   {

**                           account for the case when its state can become invalid. Refs #9402.

** 032 AL2 20250415          Allow consumers of repositionByID to decide if it should be a scan or not.

** 033 AL2 20250521          Repositioning to a row is done with NO_LOCK.

*/

/*

    * @throws  ErrorConditionException

    *          if the specified ID represents the unknown value.

    */

   {

      Long[] serIDs = new Long[] { id.longValue() };

** Module   : FqlType.java

** Abstract : Enumeration of data types for various SQL constructs

**

**

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

** 001 ECF 20080310  @37500  Created initial version. Enumeration of data types for various HQL

** 003 SVL 20120331          Added DATETIME and DATETIMETZ types.

** 004 OM  20200402          Renamed class to FqlType and move to persist package.

** 005 IAS 20201123          Added ARRAY type

*/

/*

      types.put(comhandle.class, Types.VARCHAR);

      types.put(handle.class   , Types.VARCHAR);

      types.put(object.class   , Types.VARCHAR);

      types.put(rowid.class    , Types.BIGINT);

*/

import java.util.function.*;

import java.util.logging.*;

import com.goldencode.cache.*;

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

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

import com.goldencode.p2j.persist.dirty.DirtyShareSupport;

      {

         local.closeSession(true);

         ErrorEntry ee = exc.getErrorEntry();

         handleException(ErrorManager.buildErrorText(ee.num, ee.text, ee.prefix, false), exc);

      }

      catch (PersistenceException exc)

      /** FQL statement */

      private final String fql;

      /** Does the query was generated with maximum results option? */

      private final boolean hasMaxResults;

       * 

       * @param   hql

       *          FQL statement

       * @param   maxResults

       *          Maximum results.

       * @param   startOffset

       *          Starting row offset.

       */

      {

         this.fql = hql;

         this.hasMaxResults = maxResults > 0;

         this.hasStartOffset = startOffset > 0;

         this.whereStr = relation == null ? "" : relation.getWhereString().toJavaType();

         this.lazyMode = lazyMode;

         int result = 17;

         result = 37 * result + (hasMaxResults ? 1 : 0) + (hasStartOffset ? 2 : 0);

         result = 37 * result + whereStr.hashCode();

         result = 37 * result + (lazyMode ? 1 : 0);

         QueryKey that = (QueryKey) o;

         return this.hash == that.hash                     &&

                this.hasMaxResults == that.hasMaxResults   &&

                this.hasStartOffset == that.hasStartOffset &&

                this.fql.equals(that.fql) &&

      @Override

      public String toString()

      {

      }

   }

         Query query = null;

         fql = fql.trim(); // just in case

         {

            {

         }

         // update [maxResults] and [startOffset] because the cached query might have set 

                  try

                  {

                     session.associate(record);

                  }

                  catch (StaleRecordException exc)

                  {

         try

         {

            closingSession = true;

            if (isTransactionOpen())

            {

               if (LOG.isLoggable(Level.WARNING))

         }

      }

      /**

       * Notify all registered session listeners that the current ORM session is about to

       * close or the current, implicit transaction is being committed.  Listeners which were set

** Module   : Record.java

** Abstract : The abstract base class for all business data model object classes.

**

**

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

** 001 ECF 20191001 Created initial version with basic data and accessors.

** 012 AI  20250625 Added overload of getPropertyValues(boolean).

** 013 LS  20250523 Changed getPropertyValues() to set the key of the map in a more consistent way for

**                  denormalized extents.

*/

/*

import java.util.*;

import java.util.function.*;

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

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

import com.goldencode.p2j.util.*;

extends BaseRecord

implements PropertiesDescriptor

{

   /**

    * Default constructor needed by DMOs extending this class.

    */

   {

      checkIncomplete(offset);

      return datum != null ? new integer(datum) : new integer();

   }

   {

      checkIncomplete(offset);

      return datum != null ? new datetimetz(datum) : new datetimetz();

   }

      }

   }

   /**

    * Get an {@code datetime} value for the datum at the given offset in the property array.

    * <p>

   {

      checkIncomplete(offset);

      return datum != null ? new datetime(datum) : new datetime();

   }

   {

      checkIncomplete(offset);

      return datum != null ? new date(datum) : new date();

   }

   {

      checkIncomplete(offset);

      return datum != null ? new logical(datum) : new logical();

   }

    */

   public final int64 _getInt64(int offset)

   {

      return datum != null ? new int64(datum) : new int64();

   }

   {

      checkIncomplete(offset);

      return datum != null ? new decimal(datum) : new decimal();

   }

   public final character _getCharacter(int offset)

   {

      checkIncomplete(offset);

      if (datum != null)

      {

   {

      checkIncomplete(offset);

      return datum != null ? new rowid(datum) : new rowid();

   }

   {

      checkIncomplete(offset);

      return datum != null ? handle.fromResourceId(datum, false) : new handle();

   }

   {

      checkIncomplete(offset);

      return datum != null ? new recid(datum) : new recid();

   }

    */

   protected final void _setRecid(int offset, NumberType w)

   {

      if (w != null && !w.isUnknown())

      {

      }

      setDatum(offset, datum);

   {

      checkIncomplete(offset);

      return datum != null ? new blob(datum) : new blob();

   }

   {

      checkIncomplete(offset);

   }

   /**

   {

      checkIncomplete(offset);

      return datum != null ? comhandle.fromString(datum) : new comhandle();

   }

   {

      checkIncomplete(offset);

      // the instance must be typed to Progress.Lang.Object

      object<?> res = new object<>(BaseObject.class);

   {

      checkIncomplete(offset);

      return datum != null ? new raw(datum) : raw.instantiateUnknownRaw();

   }

      RecordMeta meta = _recordMeta();

      if (oneLine)

      {

         int start = (this instanceof TempTableRecord) ? 5 : 0;

         sb.append(meta.legacyName).append('/').append(meta.tables[0]).append(':').append(id).append(" {");

         for (int i = start; i < last; i++)

               sb.append(", ");

            }

            if (isChar)

            {

               sb.append("\"");

            boolean incomplete = readFields != null && !readFields.get(i);

            if (isChar)

            {

               sb.append("\"");

            int extent = pms[i].getExtent();

            if (extent == 0)

            {

            }

            else

            {

               for (int k = 0; k < extent; k++)

               {

                  sb.append(k == 0 ? "[" : "");

               }

               i += extent - 1;

         Object val = properties.get(prop.getLegacyName());

         val = f.apply(prop, val);

         if (prop.getExtent() > 0)

         {

            for (int j = 0; j < prop.getExtent(); j++, i++)

               BaseDataType fval = (BaseDataType) Array.get(val, j);

               prop.getDataHandler().setField(data, fval, i, prop);

            }

         }

         else

         {

            prop.getDataHandler().setField(data, (BaseDataType) val, i, prop);

         }

      }

   }

   }

   /**

    * Converts this {@code Record} into a POJO, if POJO class is available.

    * To be implemented by DMO implementations.

    * 

** 412 SP  20251029          Refactor propsMap to use destination as key and source as value.

** 413 TG  20250925          Avoid openScope call for the same buffer in the current scope.

** 414 RNC 20251118          Log DirectAccessException in 'setCurrentRecord()' only if it is not expected.

*/

/*

    * Get the record ID of the current buffer's current record, if any.  P2J

    * implementation of the RECID function.

    * <p>

    *

    * @return  Record ID of the underlying data record. If no record currently

    *          backs the buffer associated with <code>dmo</code>, a recid

    *          initialized as unknown value is returned.

    */

   public recid recordID()

   {

   }

   /**

** 004 CA  20240918 Removed default methods from interfaces and moved them as concrete implementations, as

**                  default methods cause the Java metaspace to spike one order of magnitude.

** 005 AS  20241009 Refactored activeOffset into activeOffsets(Bitset).

*/

/*

package com.goldencode.p2j.persist;

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

import com.goldencode.p2j.util.object;

extends Record

implements TempTableRecord

{

   /** The property/column name of "__error-flag__" field. */

   public static final String _ERROR_FLAG = "_errorFlag";

   @Override

   public final Long _peerRowid()

   {

   }

   /**

   @Override

   public final Integer _rowState()

   {

   }

   /**

   @Override

   public final Long _originRowid()

   {

   }

   /**

   @Override

   public final Long _datasourceRowid()

   {

   }

   /**

   @Override

   public final Integer _errorFlags()

   {

   }

   /**

   @Override

   public final String _errorString()

   {

   }

   /**

      Class<?> implIFace = _recordMeta().getDmoMeta().getAnnotatedInterface();

      TemporaryBuffer.updateObjectRefCount(implIFace, oldVal, newVal);

   }

}

   }

   /**

    * @param   message

    *          The SQLException message.

    *

   /**

    * Check if Common Table Expressions should be used for converted CONTAINS operator

    * 

    */

   public boolean useCTE4Contains()

   {

   public abstract void generateWordTablesDDLImpl(String dbName,

                                                  PrintStream out,

                                                  String eoln,

   /**

    * Create a data object, the purpose of which is specific to a particular

   {

      return null;

   }

   /**

    * Use the provided database connection to extract the collation used by the database and report it

import com.goldencode.p2j.directory.*;

import com.goldencode.p2j.persist.*;

import com.goldencode.p2j.persist.Database;

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

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

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

** 054 OM  20250701          Multiple signatures changes in super class.

** 055 OM  20250718          Added new method: isSequenceMissing(Throwable).

** 056 OM  20250731          Dropped dead code related to old technology no longer in use.

*/

/*

   {

      fwd2sql.put("integer",    "integer");

      fwd2sql.put("Integer",    "integer");

      fwd2sql.put("int64",      "bigint");

      fwd2sql.put("Long",       "bigint");

      fwd2sql.put("rowid",      "bigint");

** 061 OM  20250718          Added new method: isSequenceMissing(Throwable).

** 062 OM  20250731          Dropped dead code related to old technology no longer in use.

** 063 OM  20250922          Simplified MSSQL indexes.

*/

/*

   {

      fwd2sql.put("integer",    "int4");

      fwd2sql.put("Integer",    "int4");

      fwd2sql.put("int64",      "int8");

      fwd2sql.put("Long",       "int8");

      fwd2sql.put("rowid",      "int8");

** 013 ES  20250827 Make direction of the primary key to always use ascendent direction.

** 014 OM  20250918 Droped NULL components from indexes. Added PK for unique indexes.

** 015 RNC 20260127 Added SQLSERVER_LIKE_PATTERN_OPERATORS.

*/

/*

      indexFieldSizes.put(integer.class,     4); // int

      indexFieldSizes.put(logical.class,     1); // bit

      indexFieldSizes.put(int64.class,       8); // bigint

      indexFieldSizes.put(datetimetz.class, 10); // datetimeoffset

      indexFieldSizes.put(datetime.class,    8); // datetime2

      indexFieldSizes.put(date.class,        3); // date

      fwd2sql.put("integer",    "int");

      fwd2sql.put("Integer",    "int");

      fwd2sql.put("int64",      "bigint");

      fwd2sql.put("Long",       "bigint");

      fwd2sql.put("rowid",      "bigint");

               indexUpdateStates.remove(ident);

            }

            Session session = null;

            boolean inTx = false;

            {

               session = new Session(dirtyDatabase);

               inTx = session.beginTransaction();

               query.setParameter(0, id);

               query.executeUpdate(session);

               session.commit();

   }

   /**

    * per row, each element in the list will be an array of {@code Object}s.

    * <p>

    * No locking is attempted.

** 026 SP  20240516          Process the function name in getTypeFunction() when there is an underscore

** 027 CA  20241107          Added character constant support.

** 028 ICP 20250123          Added support for integer and int64 constants.

*/

/*

      // P2J wrapper types.

      classes.put(logical.class    , FqlType.BOOLEAN);

      classes.put(integer.class    , FqlType.INTEGER);

      classes.put(decimal.class    , FqlType.DECIMAL);

      classes.put(date.class       , FqlType.DATE);

      classes.put(raw.class        , FqlType.RAW);

** 032 OM  20250331 Make sure the [byName] map's keys are in lowercase. Avoid possible duplication of default

**                  tenant record in _tenant meta table.

** 033 SP  20250321 Removed support for custom denormalized extents.

*/

/*

   private static final boolean LOG_INFO = log.isLoggable(Level.INFO);

   /** The recid of the database in {@code _Db} table. */

   /** Map of data type names to associated _Field._dtype value */

   private static final Map<String, Integer> DTYPE = Collections.unmodifiableMap(

            put("logical", "bit");

            put("integer", "integer");

            put("decimal", "numetic");

            put("raw", "varbinary");

            put("blob", "varbinary");

            put("clob", "varchar");

         // extract the list of indices of this table ...

         PreparedStatement stmt = conn.prepareStatement(

               "select " + Session.PK + " from meta_index where file_recid=?");

         ResultSet rs = stmt.executeQuery();

         while (rs.next())

         {

            // ... and drop their index components

         }

         rs.close();

         stmt.close();

         // then, delete them from _Index

         // next, delete from _Field

         // finally, delete from _File

         if (inTx)

         {

      }

      long fileNum = nextId(meta, SystemTable._File.fileName);

      Map<SystemTable, List<Map<Tuple<String, Integer>, Object>>> children =

      setMetaTableRecord(p, fileHelper,

            new FileTableRecordBuilder()

                  .put(Session.PK, fileNum)

                  .put("fileNumber", integer.of(fileNum))

                  .put("tblType", character.of("T"))

                  .build(dmoIface, pk, children)

      );

      templateRecords.put(dmoImpl, -fileNum);

      FILE_NUM.computeIfAbsent(primary, d -> new ConcurrentHashMap<>()).

      FILE_NUM_BY_TBL_NAME.computeIfAbsent(primary, d -> new ConcurrentHashMap<>()).

      saveChildren(p, children);

      if ((isDynamic && LOG_INFO) || log.isLoggable(Level.FINE))

         return false;

      }

      Map<SystemTable, List<Map<Tuple<String, Integer>, Object>>> children = childData(

            metaDb, dmoIface, systemTable.fileNum, pk);

      long id = nextId(metaDb, SystemTable._File.fileName);

      setMetaTableRecord(p, fileHelper,

            new FileTableRecordBuilder()

                  .put(Session.PK, id)

                  .put("tblType", new character("S"))

                  .build(dmoIface, pk, children)

      );

                  new MapBuilder<>().

                     put(Session.PK, nextId).

                     put("seqName", new character(seq.legacy())).

                     put("cycleOk",new logical(seq.cycle())).

                     put("dbRecid",new recid(nextId)).

            );

         }

      } catch (NoSuchMethodException | SecurityException | 

      setMetaTableRecord(p, h,

            new MapBuilder<>()

                  .put("dbName",  new character("_meta"))

                  .put("dbType",  new character(""))

                  .put("dbComm",  new character(""))

   private static Map<SystemTable, List<Map<Tuple<String, Integer>, Object>>> childData(

             Database metaDb,

             Class<? extends DataModelObject> dmoIface,

   {

      Map<SystemTable, List<Map<Tuple<String, Integer>, Object>>> children = new EnumMap<>(SystemTable.class);

      List<Map<Tuple<String, Integer>, Object>> fields = new LinkedList<>();

      List<Map<Tuple<String, Integer>, Object>> indexFields = new LinkedList<>();

      List<Map<Tuple<String, Integer>, Object>> fileTriggers = new LinkedList<>();

      List<Map<Tuple<String, Integer>, Object>> fieldTriggers = new LinkedList<>();

      Map<String, integer> fieldRposByName = new LinkedHashMap<>();

      children.put(SystemTable._Field, fields);

      children.put(SystemTable._Index, indexes);

         String field = trigger.field();

         if (!field.isEmpty())

         {

            integer fieldRpos = fieldRposByName.get(field);

            if (fieldRecId == null || fieldRpos == null)

            {

                  new MapBuilder<>().

                  put(Session.PK, nextId(metaDb, SystemTable._Field_Trig.fileName)).

                  put("fieldRecid", fieldRecId).

                  put("fieldRpos", fieldRpos).

                  put("event", new character(trigger.event())).

                  put("procName", new character(trigger.procedure())).

            fileTriggers.add(

                  new MapBuilder<>().

                  put(Session.PK, nextId(metaDb, SystemTable._File_Trig.fileName)).

                  put("event", new character(trigger.event())).

                  put("procName", new character(trigger.procedure())).

                  put("override", logical.of(trigger.overridable())).

    */

   private static void indexData(Database metaDb,

                                 String tblDmoName,

                                 Iterator<P2JIndex> indices,

                                 List<Map<Tuple<String, Integer>, Object>> indexes,

                                 List<Map<Tuple<String, Integer>, Object>> indexFields,

   {

      while (indices.hasNext())

      {

         long id = nextId(metaDb, SystemTable._Index.fileName);

         if (idx.isPrimary())

         {

         }

         indexes.add(new MapBuilder<>().

               put(Session.PK, id).

               put("indexName", new character(idx.getName())).

               put("unique", logical.of(idx.isUnique())).

               build()

         {

            P2JIndexComponent fld = comps.get(i);

            String compName = fld.getPropertyName();

            if (fieldRecid == null)

            {

            }

            indexFields.add(new MapBuilder<>().

                  put(Session.PK, nextId(metaDb, SystemTable._Index_Field.fileName)).

                  put("indexSeq", integer.of(seqNo++)).

                  build()

            );

    * @return _Field table data for a DMO field.

    */

   private static Map<Tuple<String, Integer>, Object> fieldData(Database metaDb,

                                                                Property property,

                                                                Class<?> ftype,

                                                                Map<String, integer> fieldRposByName)

   {

      long id = nextId(metaDb, SystemTable._Field.fileName);

      fieldRposByName.put(property.name, integer.of(property.order));

      int  wd = property.width;

      integer width = wd >= 0 ? integer.of(wd) : integer.UNKNOWN;

      String collation =  charField ? (caseSensitive ? "basic_S" : "basic_I") : null;

      return new MapBuilder<>().

            put(Session.PK, id).

            put("fieldName", new character(property.legacy)).

            put("dataType", character.of(typeName)).

            put("mandatory", logical.of(property.mandatory)).

       */

      public Map<Tuple<String, Integer>, Object> build(

            Class<? extends DataModelObject> dmoIface,

            Map<SystemTable, List<Map<Tuple<String, Integer>, Object>>> children)

      {

         Table table = dmoIface.getAnnotation(Table.class);

         int numfld = children.get(SystemTable._Field).size();

                put("fileName", new character(table.legacy())).

                put("owner", character.of("PUB")).

                put("userMisc", new character(table.name())).

** 003 LS  20241105 Added hasOnlyPK().

** 004 OM  20240701 Replaced + concatenation with append in StringBuilder.

**     SP  20250321 Removed usage of prop.index.

*/

/*

    * @throws  PersistenceException

    *          thrown when hydrating extents fails (as it requires extra SQL queries to be run).

    */

   throws PersistenceException

   {

      // TODO: collect extent properties and do a new query from SQL, see Loader.readExtentData()

         PropertyMeta[] propsMeta = recordMeta.getPropertyMeta(false);

         String[] loadSqls = recordMeta.loadSql;

         int[] loadSqlsIndexes = recordMeta.loadSqlIndexes;

         // only use the extent queries, skip the loadSqls[0] which contains the simple properties

         for (int i = 1; i < loadSqls.length; i++) // skip "plain" columns 

         {            

            {

               // resolve the offset in the 'props' array where this sql starts.  

               // all non-expanded extent fields are loaded even for incomplete records.

**     AL2 20231212 Use dmoMeta directly, without getter.

** 002 OM  20240715 Fixed copy/paste bug.

** 003 LS  20250714 Added 'getNeededFields' implementation.

*/

/*

import java.sql.ResultSet;

import java.sql.SQLException;

import com.goldencode.p2j.persist.*;

      return delegate.getNeededFields();

   }