# H2Map.java

    /*
    ** Module   : H2Map.java
    ** Abstract : Define a H2-backed map.
    **
    ** Copyright (c) 2020-2023, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- ---------------------------------Description----------------------------------
    ** 001 CA  20200412 Created initial version, for incremental conversion support.
    ** 002 CA  20200416 Reduce the memory footprint for incremental conversion.
    ** 003 TJD 20220504 Java 11 compatibility minor changes
    ** 004 CA  20230127 Performance improvement for incremental conversion.
    */
    /*
    ** 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.convert.db;

    import java.lang.reflect.*;
    import java.sql.*;
    import java.util.*;
    import java.util.function.*;

    import com.goldencode.ast.*;
    import com.goldencode.p2j.convert.db.LoggedCollection.AstKey;
    import com.goldencode.p2j.pattern.*;

    /**
     * A H2-backed map, which has any changes to it logged in a separate work table.
     */
    public class H2Map
    extends HashMap
    implements StoredCollection
    {
       /** A map defining custom serialization for certain values. */
       private static final Map<Class<?>, Class<? extends CustomExternalizable>>
       externalizables = new HashMap<>();

       /** The change logger for this collection. */
       protected final LoggedCollection changes = new LoggedCollection();

       /** The AST symbol resolver. */
       private final AstSymbolResolver resolver;

       /** The AST manager. */
       private final AstManager manager;

       /** The helper for SQL usage. */
       private final DBHelper helper;

       /** The map key class. */
       private final Class<?> keyClass;

       /** The map value class. */
       private final Class<?> valueClass;

       /** The map's table name. */
       private final String tableName;

       /** The map's work table name. */
       private final String workTable;

       /** The map's insert SQL. */
       private final String insertSql;

       /** The map's clear SQL. */
       private final String clearSql;

       /** The map's work table insert SQL. */
       private final String workInsertSql;

       /** The map's work table clear SQL. */
       private final String workClearSql;

       /** A custom c'tor for serializing the value. */
       private final Constructor<? extends CustomExternalizable> valueCtor;

       static
       {
          externalizables.put(Aast.class, AstExternalizble.class);
       }

       /**
        * Create a new db-backed map, with the specified name.
        *
        * @param    keyClass
        *           The map's key class.
        * @param    valueClass
        *           The map's value class.
        * @param    table
        *           The map's (and main table) name.
        * @param    helper
        *           The SQL helper.
        */
       public H2Map(Class<?> keyClass, Class<?> valueClass, String table, DBHelper helper)
       {
          this.resolver = AstSymbolResolver.getResolver();
          this.manager = AstManager.get();

          this.tableName = table;
          this.keyClass = keyClass;
          this.valueClass = valueClass;
          this.valueCtor = getCustomExternalizable(valueClass);
          this.helper = helper;

          // the main map table
          String sqlKeyType = helper.convertToSql(keyClass);
          String sqlValueType = helper.convertToSql(valueClass);

          String createSQL = "CREATE TABLE IF NOT EXISTS " + tableName +
                             " (key " +  sqlKeyType + " PRIMARY KEY, value " + sqlValueType + ");";
          helper.executeSQL(createSQL);

          // the work map table
          workTable = tableName + "__work";
          String createWorkSQL = "CREATE TABLE IF NOT EXISTS " + workTable + "(" +
                                 " fileId BIGINT NOT NULL," +
                                 " astId BIGINT NOT NULL," +
                                 " pos BIGINT AUTO_INCREMENT," +
                                 " key " + sqlKeyType + "," +
                                 " value " + sqlValueType + ");";
          helper.executeSQL(createWorkSQL);
          helper.executeSQL("CREATE UNIQUE INDEX IF NOT EXISTS idx_" + workTable + "__pk ON " +
                            workTable + " (fileId, astId, key);");
          helper.executeSQL("CREATE UNIQUE INDEX IF NOT EXISTS idx_" + workTable + "__pos ON " +
                            workTable + " (pos);");

          /*
          // load the main table
          Consumer<ResultSet> main = (rs) ->
          {
             try
             {
                Object key = rs.getObject(1);
                Object value = rs.getObject(2);

                if (this.containsKey(key))
                {
                   throw new IllegalStateException("Key already exists!");
                }

                super.put(key, value);
             }
             catch (SQLException e)
             {
                throw new RuntimeException(e);
             }
          };
          helper.executeQuery("select key, value from " + tableName, main);
          */

          // tmpTabNodes needs special processing - the value needs to be the 'authoritative' AST,
          // if it exists
          boolean specialProcessing = "tmpTabNodes".equalsIgnoreCase(table);
          Map loaded = specialProcessing ? new HashMap() : null;

          // load the work table
          Consumer<ResultSet> work = (rs) ->
          {
             try
             {
                Object key = rs.getObject(3);
                Object value = rs.getObject(4);

                /*
                if (this.containsKey(key))
                {
                   throw new IllegalStateException("Key already exists!");
                }
                */

                if (specialProcessing)
                {
                   AstExternalizble v = (AstExternalizble) value;
                   if (v.isSpecial())
                   {
                      loaded.put(key, value);
                   }
                }

                super.put(key, value);

                this.changes.log(rs.getLong(1), rs.getLong(2), key, value);
             }
             catch (SQLException e)
             {
                throw new RuntimeException(e);
             }
          };
          helper.executeQuery("select fileId, astId, key, value from " + workTable + " order by pos",
                              work);

          if (specialProcessing)
          {
             // replace any 'override' values
             super.putAll(loaded);
          }

          this.insertSql = "insert into " + tableName + " values (?, ?)";
          this.clearSql = "delete from " + tableName;

          this.workInsertSql = "INSERT INTO " + workTable + " (fileId, astId, key, value) " +
                               "VALUES (?, ?, ?, ?)";
          this.workClearSql = "delete from " + workTable;
       }

       /**
        * Constructor used for sub-classes, which delegate the db-storage to another collection.
        */
       protected H2Map()
       {
          this.resolver = AstSymbolResolver.getResolver();
          this.manager = AstManager.get();

          helper = null;
          keyClass = null;
          valueClass = null;
          valueCtor = null;
          tableName = null;
          workTable = null;
          insertSql = null;
          clearSql = null;
          workInsertSql = null;
          workClearSql = null;
       }

       /**
        * Get the value with the specified key.
        * <p>
        * If the value exists, the access will be logged.  This assumes the source AST requires for
        * the key to have this specific value.

        * @param    key
        *           The key to get the value.
        *
        * @return   The found value.
        */
       @Override
       public Object get(Object key)
       {
          Object val = super.get(key);

          if (val != null)
          {
             logChange(key, val);
          }

          return unwrapValue(val);
       }

       /**
        * Check if the map contains the specified key.
        * <p>
        * If the value exists, the access will be logged.  This assumes the source AST requires for
        * the key to have this specific value.
        *
        * @param    key
        *           The key to check.
        *
        * @return   <code>true</code> if the key exists in the map.
        */
       @Override
       public boolean containsKey(Object key)
       {
          boolean has = super.containsKey(key);

          if (has)
          {
             logChange(key, super.get(key));
          }

          return has;
       }

       /**
        * Perform a put operation.
        * <p>
        * The access will be logged.  This assumes the source AST requires for the key to have this
        * specific value.
        *
        * @param    key
        *           The key.
        * @param    value
        *           The value.
        *
        * @return   old
        *           The old value.
        */
       @Override
       public Object put(Object key, Object value)
       {
          value = wrapValue(value);

          Object old = super.put(key, value);

          logChange(key, value);

          return unwrapValue(old);
       }

       /**
        * Merge the specified map into this one.  This will rely on {@link #put} to log the access
        * to the map.
        *
        * @param    m
        *           The map to merge.
        */
       @Override
       public void putAll(Map m)
       {
          for (Object key : m.keySet())
          {
             put(key, m.get(key));
          }
       }

       /**
        * Remove this key from the map.
        * <p>
        * If the key exists, then all changes related to it will be cleared.
        *
        * @param    key
        *           The key to remove.
        *
        * @return   The old value.
        */
       @Override
       public Object remove(Object key)
       {
          Object old = super.remove(key);

          if (old != null)
          {
             changes.remove(key);
          }

          return old;
       }

       /**
        * This API is not currently supported.
        */
       @Override
       public boolean remove(Object key, Object value)
       {
          throw new UnsupportedOperationException();
       }

       /**
        * Clear the map and all its changes.
        */
       @Override
       public void clear()
       {
          super.clear();

          changes.clear();
       }

       /**
        * Persist this map and all the changes to the database.
        */
       @Override
       public void persist()
       {
          // clear the table and save the data
          helper.executeSQL(clearSql);

          helper.persistCollection(keySet(), insertSql, (PreparedStatement ps, Object key) ->
          {
             try
             {
                Object value = super.get(key);
                ps.setObject(1, key);
                ps.setObject(2, value);
                ps.addBatch();
             }
             catch (SQLException e)
             {
                throw new RuntimeException(e);
             }
          });

          // clear the work table and save the data
          helper.executeSQL(workClearSql);

          // ensure the changes are in sync with the main collection
          changes.retainAll(keySet());

          changes.persist(workInsertSql, helper, (AstKey key, Object val) ->
          {
             return new Object[] { key.fileId, key.astId, key.key, val };
          });
       }

       /**
        * Force the map to have logged a specific value for this key, in the context of the current
        * source AST.
        *
        * @param    key
        *           The map key.
        * @param    value
        *           The value to be logged as 'forced'.
        */
       public void forceChange(Object key, Object value)
       {
          // pin this change as 'mandatory'
          Aast src = resolver.getSourceAst();
          long astId = -1;
          long fileId = -1;
          if (src != null)
          {
             astId = src.getId();
             fileId = manager.getTreeId(astId);
          }
          changes.force(fileId, astId, key, wrapValue(value));
       }

       /**
        * Compact the elements of this collection, to reduce the memory footprint.
        *
        * @param    fileId
        *           The AST file ID which has finished processing.
        */
       public void compact(long fileId)
       {
          if (valueCtor == null)
          {
             return;
          }

          for (Object key : keySet())
          {
             Object value = super.get(key);

             ((CustomExternalizable) value).compact(fileId);
          }

          changes.compact(fileId, (value) -> ((CustomExternalizable) value).compact(fileId));
       }

       /**
        * Wrap the value in a {@link CustomExternalizable}.
        *
        * @param     value
        *            The value to wrap.
        *
        * @return    See above.
        */
       @Override
       public Object wrapValue(Object value)
       {
          if (valueCtor != null)
          {
             try
             {
                value = valueCtor.newInstance(value);
             }
             catch (ReflectiveOperationException  e)
             {
                throw new RuntimeException(e);
             }
          }

          return value;
       }

       /**
        * Unwrap a value from a {@link CustomExternalizable}.
        *
        * @param     value
        *            The value to unwrap.
        *
        * @return    The real value (to be used by the actual user of the collection), as returned by
        *            {@link CustomExternalizable#getValue()}.
        */
       @Override
       public Object unwrapValue(Object value)
       {
          if (value == null)
          {
             return null;
          }

          if (valueCtor != null)
          {
             value = ((CustomExternalizable) value).getValue();
          }

          return value;
       }

       /**
        * Log this access in the map as a change.
        *
        * @param    key
        *           The map key.
        * @param    value
        *           The map value.
        */
       private void logChange(Object key, Object value)
       {
          if (inPersist())
          {
             return;
          }

          // add to work table
          Aast src = resolver.getSourceAst();
          long astId = -1;
          long fileId = -1;
          if (src != null)
          {
             astId = src.getId();
             fileId = manager.getTreeId(astId);
          }

          // log the change
          changes.log(fileId, astId, key, value);
       }

       /**
        * Find the constructor to create a new custom externalizable, for (de)serialization purposes.
        *
        * @param    clazz
        *           The value class.
        *
        * @return   The found constructor, which must have only an {@link Object} argument.
        */
       private Constructor<? extends CustomExternalizable> getCustomExternalizable(Class<?> clazz)
       {
          Class<? extends CustomExternalizable> extern = externalizables.get(clazz);
          try
          {
             Constructor<? extends CustomExternalizable> ctor = extern == null
                                                                  ? null
                                                                  : extern.getConstructor(Object.class);
             return ctor;
          }
          catch (NoSuchMethodException |
                 SecurityException e)
          {
             throw new RuntimeException(e);
          }
       }
    }