import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import java.math.BigInteger;
import java.util.Properties;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class UUIDTest {
    static SessionFactory sessionFactory ;
    static Random random = new Random();

    static {
        Properties properties = new Properties();
        properties.put("hibernate.dialect","org.hibernate.dialect.MySQLDialect");
        properties.put("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
        properties.put("hibernate.connection.url", "jdbc:mysql://localhost:3306/flux");
        properties.put("hibernate.connection.username", "root");
        properties.put("hibernate.connection.password", "");
        properties.put("hibernate.current_session_context_class", "managed");
        properties.put("connection.provider_class", "org.hibernate.c3p0.internal.C3P0ConnectionProvider");
        properties.put("hibernate.c3p0.min_size", 10);
        properties.put("hibernate.c3p0.max_size", 100);

        Configuration configuration = new Configuration().addProperties(properties);
        sessionFactory = configuration.buildSessionFactory();
    }

    public static void main(String[] args) {
        int out = Integer.parseInt(args[0]);
        int end = Integer.parseInt(args[1]);
        System.out.println("Starting test");

        ExecutorService exSvc = Executors.newFixedThreadPool(100);
        for (int j = 0; j < out; j++) {
            for (int i = 0; i < end; i++) {
                final int a = j;
                final int b = i;
                exSvc.submit(() -> insert(a, b));
            }
        }

//        sessionFactory.close();
    }

    public static void insert(int j, int i) {
        System.out.println(j+"-"+i);
        Session session = sessionFactory.openSession();
        Transaction transaction = session.getTransaction();
        transaction.begin();

        String smId = UUID.randomUUID().toString();
        SQLQuery query1 = session.createSQLQuery("insert into StateMachines (id, name, version) values (:id, :name, :version);");
        query1.setParameter("name", "sm_name-1");
        query1.setParameter("version", "1");
        query1.setParameter("id", smId);
        query1.executeUpdate();

        SQLQuery query2 = session.createSQLQuery("insert into States (name, version, stateMachineId, status) values (:name, :version, :smId, :status);");
        query2.setParameter("name", "task-1");
        query2.setParameter("version", 1);
        query2.setParameter("smId", smId);
        query2.setParameter("status", "initialized");
        query2.executeUpdate();

        Long task1 = ((BigInteger) session.createSQLQuery("SELECT LAST_INSERT_ID()").uniqueResult()).longValue();

        SQLQuery query3 = session.createSQLQuery("insert into States (name, version, stateMachineId, status) values (:name, :version, :smId, :status);");
        query3.setParameter("name", "task-2");
        query3.setParameter("version", 1);
        query3.setParameter("smId", smId);
        query3.setParameter("status", "initialized");
        query3.executeUpdate();

        Long task2 = ((BigInteger) session.createSQLQuery("SELECT LAST_INSERT_ID()").uniqueResult()).longValue();

        SQLQuery query4 = session.createSQLQuery("insert into Events (name, type, stateMachineInstanceId, status) values (:name, :type, :smId, :status);");
        query4.setParameter("name", "event-1");
        query4.setParameter("type", "type-1");
        query4.setParameter("smId", smId);
        query4.setParameter("status", "pending");
        query4.executeUpdate();

        Long event1 = ((BigInteger) session.createSQLQuery("SELECT LAST_INSERT_ID()").uniqueResult()).longValue();

        SQLQuery query5 = session.createSQLQuery("insert into Events (name, type, stateMachineInstanceId, status) values (:name, :type, :smId, :status);");
        query5.setParameter("name", "event-2");
        query5.setParameter("type", "type-2");
        query5.setParameter("smId", smId);
        query5.setParameter("status", "pending");
        query5.executeUpdate();

        Long event2 = ((BigInteger) session.createSQLQuery("SELECT LAST_INSERT_ID()").uniqueResult()).longValue();

        SQLQuery query6 = session.createSQLQuery("insert into AuditRecords (stateMachineInstanceId, stateId, stateStatus) values (:smId, :sId, :status);");
        query6.setParameter("smId", smId);
        query6.setParameter("sId", random.nextInt(100));
        query6.setParameter("status", "test-status");
        query6.executeUpdate();

        SQLQuery query7 = session.createSQLQuery("insert into AuditRecords (stateMachineInstanceId, stateId, stateStatus) values (:smId, :sId, :status);");
        query7.setParameter("smId", smId);
        query7.setParameter("sId", random.nextInt(100));
        query7.setParameter("status", "test-status");
        query7.executeUpdate();

        transaction.commit();
        session.close();


        // do updates
        Session session1 = sessionFactory.openSession();
        Transaction transaction1 = session1.getTransaction();
        transaction1.begin();

        SQLQuery query12 = session1.createSQLQuery("update Events set status=:status where id=:id");
        query12.setString("status", "triggered");
        query12.setLong("id", event1);
        query12.executeUpdate();

        SQLQuery query13 = session1.createSQLQuery("update Events set status=:status where id=:id");
        query13.setString("status", "triggered");
        query13.setLong("id", event2);
        query13.executeUpdate();

        SQLQuery query8 = session1.createSQLQuery("update States set status=:status where id=:id");
        query8.setString("status", "running");
        query8.setLong("id", task1);
        query8.executeUpdate();

        SQLQuery query9 = session1.createSQLQuery("update States set status=:status where id=:id");
        query9.setString("status", "running");
        query9.setLong("id", task2);
        query9.executeUpdate();

        SQLQuery query14 = session1.createSQLQuery("insert into AuditRecords (stateMachineInstanceId, stateId, stateStatus) values (:smId, :sId, :status);");
        query14.setParameter("smId", smId);
        query14.setParameter("sId", task1);
        query14.setParameter("status", "running");
        query14.executeUpdate();

        SQLQuery query15 = session1.createSQLQuery("insert into AuditRecords (stateMachineInstanceId, stateId, stateStatus) values (:smId, :sId, :status);");
        query15.setParameter("smId", smId);
        query15.setParameter("sId", task2);
        query15.setParameter("status", "running");
        query15.executeUpdate();

        SQLQuery query10 = session1.createSQLQuery("update States set status=:status where id=:id");
        query10.setString("status", "completed");
        query10.setLong("id", task1);
        query10.executeUpdate();

        SQLQuery query16 = session1.createSQLQuery("insert into AuditRecords (stateMachineInstanceId, stateId, stateStatus) values (:smId, :sId, :status);");
        query16.setParameter("smId", smId);
        query16.setParameter("sId", task1);
        query16.setParameter("status", "completed");
        query16.executeUpdate();

        SQLQuery query11 = session1.createSQLQuery("update States set status=:status where id=:id");
        query11.setString("status", "completed");
        query11.setLong("id", task2);
        query11.executeUpdate();

        SQLQuery query17 = session1.createSQLQuery("insert into AuditRecords (stateMachineInstanceId, stateId, stateStatus) values (:smId, :sId, :status);");
        query17.setParameter("smId", smId);
        query17.setParameter("sId", task2);
        query17.setParameter("status", "completed");
        query17.executeUpdate();

        transaction1.commit();
        session1.close();

    }
}

====================================================================================================
Tables:
----------------------------------------------------------------------------------------------------
CREATE TABLE IF NOT EXISTS `StateMachines` (
  `id` VARCHAR(64) NOT NULL,
  `name` VARCHAR(1000) NOT NULL,
  `version` SMALLINT UNSIGNED NOT NULL,
  `description` VARCHAR(10) DEFAULT NULL,
  `createdAt` TIMESTAMP(3) DEFAULT CURRENT_TIMESTAMP(3),
  `updatedAt` TIMESTAMP(3) DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
  PRIMARY KEY (`id`)
)
ENGINE=InnoDB
ROW_FORMAT=DEFAULT
DEFAULT CHARSET=utf8
AUTO_INCREMENT=1;
----------------------------------------------------------------------------------------------------
CREATE TABLE IF NOT EXISTS `States` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(255) NOT NULL,
  `version` SMALLINT UNSIGNED NOT NULL,
  `description` VARCHAR(10) DEFAULT NULL,
  `dependencies` VARCHAR(1000) DEFAULT NULL,
  `stateMachineId` VARCHAR(64) DEFAULT NULL,
  `onEntryHook` varchar(500) DEFAULT NULL,
  `task` VARCHAR(1000) DEFAULT NULL,
  `onExitHook` varchar(500) DEFAULT NULL,
  `outputEvent` varchar(500) DEFAULT NULL,
  `retryCount` INT UNSIGNED DEFAULT 0,
  `timeout` INT UNSIGNED DEFAULT NULL,
  `status` varchar(50) DEFAULT NULL,
  `rollbackStatus` varchar(50) DEFAULT NULL,
  `attemptedNoOfRetries` INT UNSIGNED DEFAULT 0,
  `createdAt` TIMESTAMP(3) DEFAULT CURRENT_TIMESTAMP(3),
  `updatedAt` TIMESTAMP(3) DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_sm_states` FOREIGN KEY (`stateMachineId`) REFERENCES `StateMachines` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
)
ENGINE=InnoDB
ROW_FORMAT=DEFAULT
DEFAULT CHARSET=utf8
AUTO_INCREMENT=1;
----------------------------------------------------------------------------------------------------
CREATE TABLE IF NOT EXISTS `Events` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(255) NOT NULL,
  `type` VARCHAR(100) NOT NULL,
  `status` VARCHAR(50) DEFAULT NULL,
  `stateMachineInstanceId` VARCHAR(64) NOT NULL,
  `eventData` BLOB,
  `eventSource` VARCHAR(100) DEFAULT NULL,
  `createdAt` TIMESTAMP(3) DEFAULT CURRENT_TIMESTAMP(3),
  `updatedAt` TIMESTAMP(3) DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
  PRIMARY KEY (`id`),
  UNIQUE KEY (`stateMachineInstanceId`, `name`),
  CONSTRAINT `FK_sm_events` FOREIGN KEY (`stateMachineInstanceId`) REFERENCES `StateMachines` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
)
ENGINE=InnoDB
ROW_FORMAT=DEFAULT
DEFAULT CHARSET=utf8
AUTO_INCREMENT=1;
----------------------------------------------------------------------------------------------------
CREATE TABLE IF NOT EXISTS `AuditRecords` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `stateMachineInstanceId` VARCHAR(64) NOT NULL,
  `stateId` BIGINT NOT NULL,
  `retryAttempt` INT UNSIGNED DEFAULT NULL,
  `stateStatus` VARCHAR(50) DEFAULT NULL,
  `stateRollbackStatus` VARCHAR(50) DEFAULT NULL,
  `errors` VARCHAR(1000) DEFAULT NULL,
  `createdAt` TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
  PRIMARY KEY (`id`),
  KEY `index_audit_on_SM_instance_id` (`stateMachineInstanceId`)
)
ENGINE=InnoDB
ROW_FORMAT=DEFAULT
DEFAULT CHARSET=utf8
AUTO_INCREMENT=1;