Merged feature/rdbms-connection-pool into dev

qqq-backend-core/pom.xml

@@ -192,6 +192,13 @@
          <version>2.3.2</version>
       </dependency>
 
+      <!-- bring in a newer version of this lib, which quartz transitively loads through c3p0 -->
+      <dependency>
+         <groupId>com.mchange</groupId>
+         <artifactId>mchange-commons-java</artifactId>
+         <version>0.3.0</version>
+      </dependency>
+
       <!-- Many of the deps we bring in use slf4j.  This dep maps slf4j to our logger, log4j -->
       <dependency>
          <groupId>org.apache.logging.log4j</groupId>

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/ExportAction.java

@@ -44,6 +44,7 @@ import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportOutput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportFormat;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
@@ -216,7 +217,8 @@ public class ExportAction
       }
       queryInput.getFilter().setLimit(exportInput.getLimit());
       queryInput.setShouldTranslatePossibleValues(true);
-      queryInput.withQueryHint(QueryInput.QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS);
+      queryInput.withQueryHint(QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS);
+      queryInput.withQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
 
       /////////////////////////////////////////////////////////////////
       // tell this query that it needs to put its output into a pipe //

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/GenerateReportAction.java

@@ -59,6 +59,7 @@ import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportFormat;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportInput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.JoinsContext;
@@ -417,7 +418,8 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
             queryInput.setTableName(dataSource.getSourceTable());
             queryInput.setFilter(queryFilter);
             queryInput.setQueryJoins(dataSource.getQueryJoins());
-            queryInput.withQueryHint(QueryInput.QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS);
+            queryInput.withQueryHint(QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS);
+            queryInput.withQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
 
             queryInput.setShouldTranslatePossibleValues(true);
             queryInput.setFieldsToTranslatePossibleValues(setupFieldsToTranslatePossibleValues(reportInput, dataSource, new JoinsContext(reportInput.getInstance(), dataSource.getSourceTable(), dataSource.getQueryJoins(), queryInput.getFilter())));

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/values/QPossibleValueTranslator.java

@@ -32,13 +32,12 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QValueException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
-import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
@@ -78,45 +77,6 @@ public class QPossibleValueTranslator
 
    private int maxSizePerPvsCache = 50_000;
 
-   private Map<String, QBackendTransaction> transactionsPerTable = new HashMap<>();
-
-   // todo not commit - remove instance & session - use Context
-
-
-   boolean useTransactionsAsConnectionPool = false;
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private QBackendTransaction getTransaction(String tableName)
-   {
-      /////////////////////////////////////////////////////////////
-      // mmm, this does cut down on connections used -           //
-      // especially seems helpful in big exports.                //
-      // but, let's just start using connection pools instead... //
-      /////////////////////////////////////////////////////////////
-      if(useTransactionsAsConnectionPool)
-      {
-         try
-         {
-            if(!transactionsPerTable.containsKey(tableName))
-            {
-               transactionsPerTable.put(tableName, QBackendTransaction.openFor(new InsertInput(tableName)));
-            }
-
-            return (transactionsPerTable.get(tableName));
-         }
-         catch(Exception e)
-         {
-            LOG.warn("Error opening transaction for table", logPair("tableName", tableName));
-         }
-      }
-
-      return null;
-   }
-
 
 
    /*******************************************************************************
@@ -601,7 +561,7 @@ public class QPossibleValueTranslator
             QueryInput queryInput = new QueryInput();
             queryInput.setTableName(tableName);
             queryInput.setFilter(new QQueryFilter().withCriteria(new QFilterCriteria(idField, QCriteriaOperator.IN, page)));
-            queryInput.setTransaction(getTransaction(tableName));
+            queryInput.hasQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
 
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             // when querying for possible values, we do want to generate their display values, which makes record labels, which are usually used as PVS labels //

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/QueryHint.java

@@ -0,0 +1,38 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2024.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * 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 should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.model.actions.tables;
+
+
+/*******************************************************************************
+ ** Information about the query that an application (or qqq service) may know and
+ ** want to tell the backend, that can help influence how the backend processes
+ ** query.
+ **
+ ** For example, a query with potentially a large result set, for MySQL backend,
+ ** we may want to configure the result set to stream results rather than do its
+ ** default in-memory thing.  See RDBMSQueryAction for usage.
+ *******************************************************************************/
+public enum QueryHint
+{
+   POTENTIALLY_LARGE_NUMBER_OF_RESULTS,
+   MAY_USE_READ_ONLY_BACKEND
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/aggregate/AggregateInput.java

@@ -23,8 +23,10 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.aggregate;
 
 
 import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.List;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
 
@@ -44,6 +46,8 @@ public class AggregateInput extends AbstractTableActionInput
 
    private List<QueryJoin> queryJoins = null;
 
+   private EnumSet<QueryHint> queryHints = EnumSet.noneOf(QueryHint.class);
+
 
 
    /*******************************************************************************
@@ -302,4 +306,78 @@ public class AggregateInput extends AbstractTableActionInput
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for queryHints
+    *******************************************************************************/
+   public EnumSet<QueryHint> getQueryHints()
+   {
+      return (this.queryHints);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for queryHints
+    *******************************************************************************/
+   public void setQueryHints(EnumSet<QueryHint> queryHints)
+   {
+      this.queryHints = queryHints;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public AggregateInput withQueryHints(EnumSet<QueryHint> queryHints)
+   {
+      this.queryHints = queryHints;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public AggregateInput withQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints == null)
+      {
+         this.queryHints = EnumSet.noneOf(QueryHint.class);
+      }
+      this.queryHints.add(queryHint);
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public AggregateInput withoutQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints != null)
+      {
+         this.queryHints.remove(queryHint);
+      }
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** null-safely check if query hints map contains the specified hint
+    *******************************************************************************/
+   public boolean hasQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints == null)
+      {
+         return (false);
+      }
+
+      return (queryHints.contains(queryHint));
+   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/count/CountInput.java

@@ -23,8 +23,10 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.count;
 
 
 import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.List;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
 
@@ -42,6 +44,8 @@ public class CountInput extends AbstractTableActionInput
    private List<QueryJoin> queryJoins           = null;
    private Boolean         includeDistinctCount = false;
 
+   private EnumSet<QueryHint> queryHints = EnumSet.noneOf(QueryHint.class);
+
 
 
    /*******************************************************************************
@@ -207,4 +211,78 @@ public class CountInput extends AbstractTableActionInput
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for queryHints
+    *******************************************************************************/
+   public EnumSet<QueryHint> getQueryHints()
+   {
+      return (this.queryHints);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for queryHints
+    *******************************************************************************/
+   public void setQueryHints(EnumSet<QueryHint> queryHints)
+   {
+      this.queryHints = queryHints;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public CountInput withQueryHints(EnumSet<QueryHint> queryHints)
+   {
+      this.queryHints = queryHints;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public CountInput withQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints == null)
+      {
+         this.queryHints = EnumSet.noneOf(QueryHint.class);
+      }
+      this.queryHints.add(queryHint);
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public CountInput withoutQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints != null)
+      {
+         this.queryHints.remove(queryHint);
+      }
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** null-safely check if query hints map contains the specified hint
+    *******************************************************************************/
+   public boolean hasQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints == null)
+      {
+         return (false);
+      }
+
+      return (queryHints.contains(queryHint));
+   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/get/GetInput.java

@@ -25,10 +25,12 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.get;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
 import java.util.Map;
 import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.QueryOrGetInputInterface;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
 
@@ -60,6 +62,8 @@ public class GetInput extends AbstractTableActionInput implements QueryOrGetInpu
    private boolean            includeAssociations       = false;
    private Collection<String> associationNamesToInclude = null;
 
+   private EnumSet<QueryHint> queryHints = EnumSet.noneOf(QueryHint.class);
+
 
 
    /*******************************************************************************
@@ -462,4 +466,79 @@ public class GetInput extends AbstractTableActionInput implements QueryOrGetInpu
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for queryHints
+    *******************************************************************************/
+   public EnumSet<QueryHint> getQueryHints()
+   {
+      return (this.queryHints);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for queryHints
+    *******************************************************************************/
+   public void setQueryHints(EnumSet<QueryHint> queryHints)
+   {
+      this.queryHints = queryHints;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public GetInput withQueryHints(EnumSet<QueryHint> queryHints)
+   {
+      this.queryHints = queryHints;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public GetInput withQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints == null)
+      {
+         this.queryHints = EnumSet.noneOf(QueryHint.class);
+      }
+      this.queryHints.add(queryHint);
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for queryHints
+    *******************************************************************************/
+   public GetInput withoutQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints != null)
+      {
+         this.queryHints.remove(queryHint);
+      }
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** null-safely check if query hints map contains the specified hint
+    *******************************************************************************/
+   public boolean hasQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints == null)
+      {
+         return (false);
+      }
+
+      return (queryHints.contains(queryHint));
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/QueryInput.java

@@ -31,12 +31,16 @@ import java.util.Set;
 import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
 import com.kingsrook.qqq.backend.core.actions.reporting.RecordPipe;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.QueryOrGetInputInterface;
 
 
 /*******************************************************************************
  ** Input data for the Query action
  **
+ ** Todo - maybe make a class between AbstractTableActionInput and {QueryInput,
+ ** CountInput, and AggregateInput}, with common attributes for all of these
+ ** "read" operations (like, queryHints,
  *******************************************************************************/
 public class QueryInput extends AbstractTableActionInput implements QueryOrGetInputInterface, Cloneable
 {
@@ -74,22 +78,6 @@ public class QueryInput extends AbstractTableActionInput implements QueryOrGetIn
 
 
 
-   /*******************************************************************************
-    ** Information about the query that an application (or qqq service) may know and
-    ** want to tell the backend, that can help influence how the backend processes
-    ** query.
-    **
-    ** For example, a query with potentially a large result set, for MySQL backend,
-    ** we may want to configure the result set to stream results rather than do its
-    ** default in-memory thing.  See RDBMSQueryAction for usage.
-    *******************************************************************************/
-   public enum QueryHint
-   {
-      POTENTIALLY_LARGE_NUMBER_OF_RESULTS
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -683,4 +671,19 @@ public class QueryInput extends AbstractTableActionInput implements QueryOrGetIn
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** null-safely check if query hints map contains the specified hint
+    *******************************************************************************/
+   public boolean hasQueryHint(QueryHint queryHint)
+   {
+      if(this.queryHints == null)
+      {
+         return (false);
+      }
+
+      return (queryHints.contains(queryHint));
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/implementations/garbagecollector/GarbageCollectorExtractStep.java

@@ -25,6 +25,7 @@ package com.kingsrook.qqq.backend.core.processes.implementations.garbagecollecto
 import java.time.Instant;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.processes.implementations.etl.streamedwithfrontend.ExtractViaQueryStep;
@@ -66,7 +67,7 @@ public class GarbageCollectorExtractStep extends ExtractViaQueryStep
    @Override
    protected void customizeInputPreQuery(QueryInput queryInput)
    {
-      queryInput.withQueryHint(QueryInput.QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS);
+      queryInput.withQueryHint(QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS);
    }
 
 }

qqq-backend-module-rdbms/pom.xml

@@ -50,6 +50,11 @@
          <artifactId>mysql-connector-java</artifactId>
          <version>8.0.30</version>
       </dependency>
+      <dependency>
+         <groupId>com.mchange</groupId>
+         <artifactId>c3p0</artifactId>
+         <version>0.10.0</version>
+      </dependency>
       <dependency>
          <groupId>com.h2database</groupId>
          <artifactId>h2</artifactId>

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/actions/AbstractRDBMSAction.java

@@ -47,14 +47,19 @@ import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QValueException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.Aggregate;
+import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.AggregateInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.GroupBy;
 import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.QFilterOrderByAggregate;
 import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.QFilterOrderByGroupBy;
+import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.JoinsContext;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterOrderBy;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.expressions.AbstractFilterExpression;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
@@ -135,11 +140,38 @@ public abstract class AbstractRDBMSAction
 
    /*******************************************************************************
     ** Get a database connection, per the backend in the request.
+    **
+    ** Note that it may be a connection to a read-only backend, per query-hints,
+    ** and backend settings.
     *******************************************************************************/
-   public static Connection getConnection(AbstractTableActionInput qTableRequest) throws SQLException
+   public static Connection getConnection(AbstractTableActionInput tableActionInput) throws SQLException
    {
-      ConnectionManager connectionManager = new ConnectionManager();
+      RDBMSBackendMetaData backend = (RDBMSBackendMetaData) tableActionInput.getBackend();
-      return connectionManager.getConnection((RDBMSBackendMetaData) qTableRequest.getBackend());
+
+      boolean useReadOnly = false;
+      if(tableActionInput instanceof QueryInput queryInput)
+      {
+         useReadOnly = queryInput.hasQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
+      }
+      else if(tableActionInput instanceof CountInput countInput)
+      {
+         useReadOnly = countInput.hasQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
+      }
+      else if(tableActionInput instanceof GetInput getInput)
+      {
+         useReadOnly = getInput.hasQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
+      }
+      else if(tableActionInput instanceof AggregateInput aggregateInput)
+      {
+         useReadOnly = aggregateInput.hasQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
+      }
+
+      if(useReadOnly && backend.getReadOnlyBackendMetaData() != null)
+      {
+         return ConnectionManager.getConnection(backend.getReadOnlyBackendMetaData());
+      }
+
+      return ConnectionManager.getConnection(backend);
    }
 
 

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/actions/RDBMSInsertAction.java

@@ -24,6 +24,7 @@ package com.kingsrook.qqq.backend.module.rdbms.actions;
 
 import java.io.Serializable;
 import java.sql.Connection;
+import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -56,6 +57,9 @@ public class RDBMSInsertAction extends AbstractRDBMSAction implements InsertInte
       InsertOutput   rs    = new InsertOutput();
       QTableMetaData table = insertInput.getTable();
 
+      Connection connection = null;
+      boolean    needToCloseConnection = false;
+
       try
       {
          List<QFieldMetaData> insertableFields = table.getFields().values().stream()
@@ -72,8 +76,6 @@ public class RDBMSInsertAction extends AbstractRDBMSAction implements InsertInte
          List<QRecord> outputRecords = new ArrayList<>();
          rs.setRecords(outputRecords);
 
-         Connection connection;
-         boolean    needToCloseConnection = false;
          if(insertInput.getTransaction() != null && insertInput.getTransaction() instanceof RDBMSTransaction rdbmsTransaction)
          {
             connection = rdbmsTransaction.getConnection();
@@ -84,8 +86,6 @@ public class RDBMSInsertAction extends AbstractRDBMSAction implements InsertInte
             needToCloseConnection = true;
          }
 
-         try
-         {
          for(List<QRecord> page : CollectionUtils.getPages(insertInput.getRecords(), QueryManager.PAGE_SIZE))
          {
             String        tableName   = escapeIdentifier(getTableName(table));
@@ -158,14 +158,6 @@ public class RDBMSInsertAction extends AbstractRDBMSAction implements InsertInte
 
             logSQL(sql, params, mark);
          }
-         }
-         finally
-         {
-            if(needToCloseConnection)
-            {
-               connection.close();
-            }
-         }
 
          return rs;
       }
@@ -173,6 +165,21 @@ public class RDBMSInsertAction extends AbstractRDBMSAction implements InsertInte
       {
          throw new QException("Error executing insert: " + e.getMessage(), e);
       }
+      finally
+      {
+         if(needToCloseConnection && connection != null)
+         {
+            try
+            {
+               connection.close();
+            }
+            catch(SQLException se)
+            {
+               LOG.error("Error closing database connection", se);
+            }
+         }
+      }
+
    }
 
 }

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/actions/RDBMSQueryAction.java

@@ -41,6 +41,7 @@ import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QUserFacingException;
 import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.JoinsContext;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
@@ -80,7 +81,6 @@ public class RDBMSQueryAction extends AbstractRDBMSAction implements QueryInterf
       }
    }
 
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -361,7 +361,7 @@ public class RDBMSQueryAction extends AbstractRDBMSAction implements QueryInterf
          ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // if we're allowed to use the mysqlResultSetOptimization, and we have the query hint of "expected large result set", then do it. //
          ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         if(mysqlResultSetOptimizationEnabled && queryInput.getQueryHints() != null && queryInput.getQueryHints().contains(QueryInput.QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS))
+         if(mysqlResultSetOptimizationEnabled && queryInput.getQueryHints() != null && queryInput.getQueryHints().contains(QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS))
          {
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             // mysql "optimization", presumably here - from Result Set section of https://dev.mysql.com/doc/connector-j/en/connector-j-reference-implementation-notes.html //

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/jdbc/C3P0PooledConnectionProvider.java

@@ -0,0 +1,182 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2024.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * 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 should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.module.rdbms.jdbc;
+
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.LinkedHashMap;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.module.rdbms.model.metadata.ConnectionPoolSettings;
+import com.kingsrook.qqq.backend.module.rdbms.model.metadata.RDBMSBackendMetaData;
+import com.mchange.v2.c3p0.ComboPooledDataSource;
+import org.json.JSONObject;
+import static com.kingsrook.qqq.backend.module.rdbms.jdbc.ConnectionManager.getJdbcUrl;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class C3P0PooledConnectionProvider implements ConnectionProviderInterface
+{
+   private RDBMSBackendMetaData  backend;
+   private ComboPooledDataSource connectionPool;
+
+   private long usageCount = 0;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void init(RDBMSBackendMetaData backend) throws QException
+   {
+      this.backend = backend;
+
+      try
+      {
+         ComboPooledDataSource pool = new ComboPooledDataSource();
+         pool.setDriverClass(ConnectionManager.getJdbcDriverClassName(backend));
+         pool.setJdbcUrl(getJdbcUrl(backend));
+         pool.setUser(backend.getUsername());
+         pool.setPassword(backend.getPassword());
+
+         ConnectionPoolSettings poolSettings = backend.getConnectionPoolSettings();
+         if(poolSettings != null)
+         {
+            if(poolSettings.getInitialPoolSize() != null)
+            {
+               pool.setInitialPoolSize(poolSettings.getInitialPoolSize());
+            }
+
+            if(poolSettings.getMinPoolSize() != null)
+            {
+               pool.setMinPoolSize(poolSettings.getMinPoolSize());
+            }
+
+            if(poolSettings.getMaxPoolSize() != null)
+            {
+               pool.setMaxPoolSize(poolSettings.getMaxPoolSize());
+            }
+
+            if(poolSettings.getAcquireIncrement() != null)
+            {
+               pool.setAcquireIncrement(poolSettings.getAcquireIncrement());
+            }
+
+            if(poolSettings.getMaxConnectionAgeSeconds() != null)
+            {
+               pool.setMaxConnectionAge(poolSettings.getMaxConnectionAgeSeconds());
+            }
+
+            if(poolSettings.getMaxIdleTimeSeconds() != null)
+            {
+               pool.setMaxIdleTime(poolSettings.getMaxIdleTimeSeconds());
+            }
+
+            if(poolSettings.getMaxIdleTimeExcessConnectionsSeconds() != null)
+            {
+               pool.setMaxIdleTimeExcessConnections(poolSettings.getMaxIdleTimeExcessConnectionsSeconds());
+            }
+
+            if(poolSettings.getCheckoutTimeoutSeconds() != null)
+            {
+               pool.setCheckoutTimeout(poolSettings.getCheckoutTimeoutSeconds() * 1000);
+            }
+
+            if(poolSettings.getTestConnectionOnCheckout() != null)
+            {
+               pool.setTestConnectionOnCheckout(poolSettings.getTestConnectionOnCheckout());
+            }
+         }
+
+         customizePool(pool);
+
+         this.connectionPool = pool;
+      }
+      catch(Exception e)
+      {
+         throw (new QException("Error Initializing C3P0PooledConnectionProvider for backend [" + backend.getName() + "]", e));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   protected void customizePool(ComboPooledDataSource pool)
+   {
+      ////////////////////////
+      // noop in base class //
+      ////////////////////////
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public Connection getConnection() throws SQLException
+   {
+      usageCount++;
+      return (this.connectionPool.getConnection());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public JSONObject dumpDebug() throws SQLException
+   {
+      JSONObject rs = new JSONObject(new LinkedHashMap<>());
+
+      JSONObject settings = new JSONObject(new LinkedHashMap<>());
+      rs.put("settings", settings);
+      settings.put("initialPoolSize", connectionPool.getInitialPoolSize());
+      settings.put("minPoolSize", connectionPool.getMinPoolSize());
+      settings.put("maxPoolSize", connectionPool.getMaxPoolSize());
+      settings.put("acquireIncrement", connectionPool.getAcquireIncrement());
+      settings.put("maxConnectionAge", connectionPool.getMaxConnectionAge());
+      settings.put("maxIdleTime", connectionPool.getMaxIdleTime());
+      settings.put("maxIdleTimeExcessConnections", connectionPool.getMaxIdleTimeExcessConnections());
+      settings.put("checkoutTimeout", connectionPool.getCheckoutTimeout());
+      settings.put("testConnectionOnCheckout", connectionPool.isTestConnectionOnCheckout());
+
+      JSONObject state = new JSONObject(new LinkedHashMap<>());
+      rs.put("state", state);
+      state.put("numUsages", usageCount);
+      state.put("numConnections", connectionPool.getNumConnections());
+      state.put("numBusyConnections", connectionPool.getNumBusyConnections());
+      state.put("numIdleConnections", connectionPool.getNumIdleConnections());
+      state.put("numFailedCheckins", connectionPool.getNumFailedCheckinsDefaultUser());
+      state.put("numFailedCheckouts", connectionPool.getNumFailedCheckoutsDefaultUser());
+      state.put("numFailedIdleTests", connectionPool.getNumFailedIdleTestsDefaultUser());
+      state.put("numThreadsAwaitingCheckout", connectionPool.getNumThreadsAwaitingCheckoutDefaultUser());
+      return (rs);
+   }
+
+}

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/jdbc/ConnectionManager.java

@@ -23,25 +23,117 @@ package com.kingsrook.qqq.backend.module.rdbms.jdbc;
 
 
 import java.sql.Connection;
-import java.sql.DriverManager;
 import java.sql.SQLException;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.module.rdbms.model.metadata.RDBMSBackendMetaData;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
+ ** Class to manage access to JDBC Connections.
  **
+ ** Relies heavily on RDBMSBackendMetaData.
  *******************************************************************************/
 public class ConnectionManager
 {
+   private static final QLogger LOG = QLogger.getLogger(ConnectionManager.class);
+
+   private static final Map<String, ConnectionProviderInterface> connectionProviderMap = new ConcurrentHashMap<>();
+
+
 
    /*******************************************************************************
     **
     *******************************************************************************/
-   public Connection getConnection(RDBMSBackendMetaData backend) throws SQLException
+   public static Connection getConnection(RDBMSBackendMetaData backend) throws SQLException
    {
-      String jdbcURL = getJdbcUrl(backend);
+      try
-      return DriverManager.getConnection(jdbcURL, backend.getUsername(), backend.getPassword());
+      {
+         ConnectionProviderInterface connectionProvider = getConnectionProvider(backend);
+         return connectionProvider.getConnection();
+      }
+      catch(QException qe)
+      {
+         throw (new SQLException("Error getting connection", qe));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static ConnectionProviderInterface getConnectionProvider(RDBMSBackendMetaData backend) throws QException
+   {
+      String name = Objects.requireNonNullElse(backend.getName(), "");
+      if(!StringUtils.hasContent(name))
+      {
+         throw (new QException("RDBMSBackendMetaData is missing a name"));
+      }
+
+      if(!connectionProviderMap.containsKey(name))
+      {
+         synchronized(connectionProviderMap)
+         {
+            if(!connectionProviderMap.containsKey(name))
+            {
+               QCodeReference connectionProviderReference = backend.getConnectionProvider();
+               boolean        usingDefaultSimpleProvider  = false;
+               if(connectionProviderReference == null)
+               {
+                  connectionProviderReference = new QCodeReference(SimpleConnectionProvider.class);
+                  usingDefaultSimpleProvider = true;
+               }
+
+               LOG.info("Initializing connection provider for RDBMS backend", logPair("backendName", name), logPair("connectionProvider", connectionProviderReference.getName()), logPair("usingDefaultSimpleProvider", usingDefaultSimpleProvider));
+               ConnectionProviderInterface connectionProvider = QCodeLoader.getAdHoc(ConnectionProviderInterface.class, connectionProviderReference);
+               connectionProvider.init(backend);
+
+               connectionProviderMap.put(name, connectionProvider);
+            }
+         }
+      }
+
+      return (connectionProviderMap.get(name));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static JSONArray dumpConnectionProviderDebug()
+   {
+      try
+      {
+         JSONArray rs = new JSONArray();
+         for(Map.Entry<String, ConnectionProviderInterface> entry : connectionProviderMap.entrySet())
+         {
+            JSONObject jsonObject = new JSONObject(new LinkedHashMap<>());
+            jsonObject.put("backendName", entry.getKey());
+            jsonObject.put("connectionProviderClass", entry.getValue().getClass().getName());
+            jsonObject.put("values", entry.getValue().dumpDebug());
+            rs.put(jsonObject);
+         }
+
+         return (rs);
+      }
+      catch(Exception e)
+      {
+         String message = "Error dumping debug data for connection providers";
+         LOG.warn(message, e);
+         return (new JSONArray(new JSONObject(Map.of("error", e.getMessage()))));
+      }
    }
 
 
@@ -87,4 +179,14 @@ public class ConnectionManager
       };
    }
 
+
+
+   /*******************************************************************************
+    ** reset the map of connection providers - not necessarily meant to be useful
+    ** in production code - written for use in qqq tests.
+    *******************************************************************************/
+   static void resetConnectionProviders()
+   {
+      connectionProviderMap.clear();
+   }
 }

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/jdbc/ConnectionProviderInterface.java

@@ -0,0 +1,58 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2024.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * 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 should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.module.rdbms.jdbc;
+
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.module.rdbms.model.metadata.RDBMSBackendMetaData;
+import org.json.JSONObject;
+
+
+/*******************************************************************************
+ ** interface for classes that can provide jdbc Connections for an RDBMS backend.
+ *******************************************************************************/
+public interface ConnectionProviderInterface
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   void init(RDBMSBackendMetaData backend) throws QException;
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   Connection getConnection() throws SQLException;
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default JSONObject dumpDebug() throws SQLException
+   {
+      JSONObject rs = new JSONObject();
+      rs.put("nothingToReport", true);
+      return (rs);
+   }
+}
+

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/jdbc/SimpleConnectionProvider.java

@@ -0,0 +1,63 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2024.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * 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 should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.module.rdbms.jdbc;
+
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import com.kingsrook.qqq.backend.module.rdbms.model.metadata.RDBMSBackendMetaData;
+import static com.kingsrook.qqq.backend.module.rdbms.jdbc.ConnectionManager.getJdbcUrl;
+
+
+/*******************************************************************************
+ ** Simple connection provider - no pooling, just opens a new connection for
+ ** every request.
+ *******************************************************************************/
+public class SimpleConnectionProvider implements ConnectionProviderInterface
+{
+   private RDBMSBackendMetaData backend;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void init(RDBMSBackendMetaData backend)
+   {
+      this.backend = backend;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public Connection getConnection() throws SQLException
+   {
+      String jdbcURL = getJdbcUrl(backend);
+      return DriverManager.getConnection(jdbcURL, backend.getUsername(), backend.getPassword());
+   }
+
+}

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/model/metadata/ConnectionPoolSettings.java

@@ -0,0 +1,326 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2024.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * 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 should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.module.rdbms.model.metadata;
+
+
+/*******************************************************************************
+ ** Settings for a connection pool (if your backend is configured to use one).
+ ** Originally based on the most common settings for C3P0 - see
+ ** https://www.mchange.com/projects/c3p0/#configuration
+ **
+ ** If you want more - you'll be looking at defining your own subclass of
+ ** C3P0PooledConnectionProvider and possibly this class.
+ **
+ ** If using a pool other than C3P0 - some of these may apply others may not.
+ *******************************************************************************/
+public class ConnectionPoolSettings
+{
+   private Integer initialPoolSize;
+   private Integer minPoolSize;
+   private Integer maxPoolSize;
+   private Integer acquireIncrement;
+   private Integer maxConnectionAgeSeconds;
+   private Integer maxIdleTimeSeconds;
+   private Integer maxIdleTimeExcessConnectionsSeconds;
+   private Integer checkoutTimeoutSeconds;
+   private Boolean testConnectionOnCheckout;
+
+
+
+   /*******************************************************************************
+    ** Getter for initialPoolSize
+    *******************************************************************************/
+   public Integer getInitialPoolSize()
+   {
+      return (this.initialPoolSize);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for initialPoolSize
+    *******************************************************************************/
+   public void setInitialPoolSize(Integer initialPoolSize)
+   {
+      this.initialPoolSize = initialPoolSize;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for initialPoolSize
+    *******************************************************************************/
+   public ConnectionPoolSettings withInitialPoolSize(Integer initialPoolSize)
+   {
+      this.initialPoolSize = initialPoolSize;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for minPoolSize
+    *******************************************************************************/
+   public Integer getMinPoolSize()
+   {
+      return (this.minPoolSize);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for minPoolSize
+    *******************************************************************************/
+   public void setMinPoolSize(Integer minPoolSize)
+   {
+      this.minPoolSize = minPoolSize;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for minPoolSize
+    *******************************************************************************/
+   public ConnectionPoolSettings withMinPoolSize(Integer minPoolSize)
+   {
+      this.minPoolSize = minPoolSize;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for maxPoolSize
+    *******************************************************************************/
+   public Integer getMaxPoolSize()
+   {
+      return (this.maxPoolSize);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for maxPoolSize
+    *******************************************************************************/
+   public void setMaxPoolSize(Integer maxPoolSize)
+   {
+      this.maxPoolSize = maxPoolSize;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for maxPoolSize
+    *******************************************************************************/
+   public ConnectionPoolSettings withMaxPoolSize(Integer maxPoolSize)
+   {
+      this.maxPoolSize = maxPoolSize;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for acquireIncrement
+    *******************************************************************************/
+   public Integer getAcquireIncrement()
+   {
+      return (this.acquireIncrement);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for acquireIncrement
+    *******************************************************************************/
+   public void setAcquireIncrement(Integer acquireIncrement)
+   {
+      this.acquireIncrement = acquireIncrement;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for acquireIncrement
+    *******************************************************************************/
+   public ConnectionPoolSettings withAcquireIncrement(Integer acquireIncrement)
+   {
+      this.acquireIncrement = acquireIncrement;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for maxConnectionAgeSeconds
+    *******************************************************************************/
+   public Integer getMaxConnectionAgeSeconds()
+   {
+      return (this.maxConnectionAgeSeconds);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for maxConnectionAgeSeconds
+    *******************************************************************************/
+   public void setMaxConnectionAgeSeconds(Integer maxConnectionAgeSeconds)
+   {
+      this.maxConnectionAgeSeconds = maxConnectionAgeSeconds;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for maxConnectionAgeSeconds
+    *******************************************************************************/
+   public ConnectionPoolSettings withMaxConnectionAgeSeconds(Integer maxConnectionAgeSeconds)
+   {
+      this.maxConnectionAgeSeconds = maxConnectionAgeSeconds;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for maxIdleTimeSeconds
+    *******************************************************************************/
+   public Integer getMaxIdleTimeSeconds()
+   {
+      return (this.maxIdleTimeSeconds);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for maxIdleTimeSeconds
+    *******************************************************************************/
+   public void setMaxIdleTimeSeconds(Integer maxIdleTimeSeconds)
+   {
+      this.maxIdleTimeSeconds = maxIdleTimeSeconds;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for maxIdleTimeSeconds
+    *******************************************************************************/
+   public ConnectionPoolSettings withMaxIdleTimeSeconds(Integer maxIdleTimeSeconds)
+   {
+      this.maxIdleTimeSeconds = maxIdleTimeSeconds;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for maxIdleTimeExcessConnectionsSeconds
+    *******************************************************************************/
+   public Integer getMaxIdleTimeExcessConnectionsSeconds()
+   {
+      return (this.maxIdleTimeExcessConnectionsSeconds);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for maxIdleTimeExcessConnectionsSeconds
+    *******************************************************************************/
+   public void setMaxIdleTimeExcessConnectionsSeconds(Integer maxIdleTimeExcessConnectionsSeconds)
+   {
+      this.maxIdleTimeExcessConnectionsSeconds = maxIdleTimeExcessConnectionsSeconds;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for maxIdleTimeExcessConnectionsSeconds
+    *******************************************************************************/
+   public ConnectionPoolSettings withMaxIdleTimeExcessConnectionsSeconds(Integer maxIdleTimeExcessConnectionsSeconds)
+   {
+      this.maxIdleTimeExcessConnectionsSeconds = maxIdleTimeExcessConnectionsSeconds;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for testConnectionOnCheckout
+    *******************************************************************************/
+   public Boolean getTestConnectionOnCheckout()
+   {
+      return (this.testConnectionOnCheckout);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for testConnectionOnCheckout
+    *******************************************************************************/
+   public void setTestConnectionOnCheckout(Boolean testConnectionOnCheckout)
+   {
+      this.testConnectionOnCheckout = testConnectionOnCheckout;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for testConnectionOnCheckout
+    *******************************************************************************/
+   public ConnectionPoolSettings withTestConnectionOnCheckout(Boolean testConnectionOnCheckout)
+   {
+      this.testConnectionOnCheckout = testConnectionOnCheckout;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for checkoutTimeoutSeconds
+    *******************************************************************************/
+   public Integer getCheckoutTimeoutSeconds()
+   {
+      return (this.checkoutTimeoutSeconds);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for checkoutTimeoutSeconds
+    *******************************************************************************/
+   public void setCheckoutTimeoutSeconds(Integer checkoutTimeoutSeconds)
+   {
+      this.checkoutTimeoutSeconds = checkoutTimeoutSeconds;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for checkoutTimeoutSeconds
+    *******************************************************************************/
+   public ConnectionPoolSettings withCheckoutTimeoutSeconds(Integer checkoutTimeoutSeconds)
+   {
+      this.checkoutTimeoutSeconds = checkoutTimeoutSeconds;
+      return (this);
+   }
+
+}

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/model/metadata/RDBMSBackendMetaData.java

@@ -24,6 +24,7 @@ package com.kingsrook.qqq.backend.module.rdbms.model.metadata;
 
 import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
 import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.module.rdbms.RDBMSBackendModule;
 
 
@@ -42,6 +43,12 @@ public class RDBMSBackendMetaData extends QBackendMetaData
    private String jdbcUrl;
    private String jdbcDriverClassName;
 
+   private QCodeReference connectionProvider;
+
+   private ConnectionPoolSettings connectionPoolSettings;
+
+   private RDBMSBackendMetaData readOnlyBackendMetaData;
+
 
 
    /*******************************************************************************
@@ -316,6 +323,7 @@ public class RDBMSBackendMetaData extends QBackendMetaData
    }
 
 
+
    /*******************************************************************************
     ** Getter for jdbcDriverClassName
     *******************************************************************************/
@@ -346,4 +354,96 @@ public class RDBMSBackendMetaData extends QBackendMetaData
    }
 
 
+
+   /*******************************************************************************
+    ** Getter for connectionProvider
+    *******************************************************************************/
+   public QCodeReference getConnectionProvider()
+   {
+      return (this.connectionProvider);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for connectionProvider
+    *******************************************************************************/
+   public void setConnectionProvider(QCodeReference connectionProvider)
+   {
+      this.connectionProvider = connectionProvider;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for connectionProvider
+    *******************************************************************************/
+   public RDBMSBackendMetaData withConnectionProvider(QCodeReference connectionProvider)
+   {
+      this.connectionProvider = connectionProvider;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for readOnlyBackendMetaData
+    *******************************************************************************/
+   public RDBMSBackendMetaData getReadOnlyBackendMetaData()
+   {
+      return (this.readOnlyBackendMetaData);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for readOnlyBackendMetaData
+    *******************************************************************************/
+   public void setReadOnlyBackendMetaData(RDBMSBackendMetaData readOnlyBackendMetaData)
+   {
+      this.readOnlyBackendMetaData = readOnlyBackendMetaData;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for readOnlyBackendMetaData
+    *******************************************************************************/
+   public RDBMSBackendMetaData withReadOnlyBackendMetaData(RDBMSBackendMetaData readOnlyBackendMetaData)
+   {
+      this.readOnlyBackendMetaData = readOnlyBackendMetaData;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for connectionPoolSettings
+    *******************************************************************************/
+   public ConnectionPoolSettings getConnectionPoolSettings()
+   {
+      return (this.connectionPoolSettings);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for connectionPoolSettings
+    *******************************************************************************/
+   public void setConnectionPoolSettings(ConnectionPoolSettings connectionPoolSettings)
+   {
+      this.connectionPoolSettings = connectionPoolSettings;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for connectionPoolSettings
+    *******************************************************************************/
+   public RDBMSBackendMetaData withConnectionPoolSettings(ConnectionPoolSettings connectionPoolSettings)
+   {
+      this.connectionPoolSettings = connectionPoolSettings;
+      return (this);
+   }
+
 }

qqq-backend-module-rdbms/src/test/java/com/kingsrook/qqq/backend/module/rdbms/actions/RDBMSActionTest.java

@@ -67,5 +67,6 @@ public class RDBMSActionTest extends BaseTest
       ConnectionManager connectionManager = new ConnectionManager();
       Connection        connection        = connectionManager.getConnection(TestUtils.defineBackend());
       QueryManager.executeStatement(connection, sql, resultSetProcessor);
+      connection.close();
    }
 }

qqq-backend-module-rdbms/src/test/java/com/kingsrook/qqq/backend/module/rdbms/jdbc/C3P0PooledConnectionProviderTest.java

@@ -0,0 +1,237 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2024.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * 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 should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.module.rdbms.jdbc;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
+import com.kingsrook.qqq.backend.core.model.session.QSession;
+import com.kingsrook.qqq.backend.core.utils.SleepUtils;
+import com.kingsrook.qqq.backend.module.rdbms.BaseTest;
+import com.kingsrook.qqq.backend.module.rdbms.TestUtils;
+import com.kingsrook.qqq.backend.module.rdbms.model.metadata.ConnectionPoolSettings;
+import com.kingsrook.qqq.backend.module.rdbms.model.metadata.RDBMSBackendMetaData;
+import com.mchange.v2.resourcepool.TimeoutException;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+
+/*******************************************************************************
+ ** Unit test for C3P0PooledConnectionProvider 
+ *******************************************************************************/
+class C3P0PooledConnectionProviderTest extends BaseTest
+{
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @BeforeEach
+   void beforeEach() throws Exception
+   {
+      TestUtils.primeTestDatabase("prime-test-database.sql");
+
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // must call this after the primeTestDatabase call (as i uses a raw version of the backend, w/o our updated settings) //
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      ConnectionManager.resetConnectionProviders();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @AfterEach
+   void afterEach()
+   {
+      ////////////////////////////////////////////////////////////
+      // just for good measure, do this after each test in here //
+      ////////////////////////////////////////////////////////////
+      ConnectionManager.resetConnectionProviders();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   // @RepeatedTest(100)
+   void test() throws Exception
+   {
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // change the default database backend to use the class under test here - the C3PL connection pool provider //
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      QInstance            qInstance = TestUtils.defineInstance();
+      RDBMSBackendMetaData backend   = (RDBMSBackendMetaData) qInstance.getBackend(TestUtils.DEFAULT_BACKEND_NAME);
+      backend.setConnectionProvider(new QCodeReference(C3P0PooledConnectionProvider.class));
+      QContext.init(qInstance, new QSession());
+
+      for(int i = 0; i < 5; i++)
+      {
+         new QueryAction().execute(new QueryInput(TestUtils.TABLE_NAME_PERSON));
+      }
+
+      JSONObject debugValues = getDebugStateValues(true);
+      assertThat(debugValues.getInt("numConnections")).isBetween(3, 6); // due to potential timing issues, sometimes pool will acquire another 3 conns, so 3 or 6 seems ok.
+
+      ////////////////////////////////////////////////////////////////////
+      // open up 4 transactions - confirm the pool opens some new conns //
+      ////////////////////////////////////////////////////////////////////
+      List<QBackendTransaction> transactions = new ArrayList<>();
+      for(int i = 0; i < 5; i++)
+      {
+         transactions.add(QBackendTransaction.openFor(new InsertInput(TestUtils.TABLE_NAME_PERSON)));
+      }
+
+      debugValues = getDebugStateValues(true);
+      assertThat(debugValues.getInt("numConnections")).isGreaterThan(3);
+
+      transactions.forEach(transaction -> transaction.close());
+
+      /////////////////////////////////////////////////////////////////////////
+      // might take a second for the pool to re-claim the closed connections //
+      /////////////////////////////////////////////////////////////////////////
+      boolean foundMatch = false;
+      for(int i = 0; i < 5; i++)
+      {
+         debugValues = getDebugStateValues(true);
+         if(debugValues.getInt("numConnections") == debugValues.getInt("numIdleConnections"))
+         {
+            foundMatch = true;
+            break;
+         }
+         System.out.println("oops!");
+         SleepUtils.sleep(250, TimeUnit.MILLISECONDS);
+      }
+
+      assertTrue(foundMatch, "The pool didn't re-claim all connections...");
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testPoolSettings() throws Exception
+   {
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // change the default database backend to use the class under test here - the C3PL connection pool provider //
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      QInstance            qInstance = TestUtils.defineInstance();
+      RDBMSBackendMetaData backend   = (RDBMSBackendMetaData) qInstance.getBackend(TestUtils.DEFAULT_BACKEND_NAME);
+      backend.setConnectionProvider(new QCodeReference(C3P0PooledConnectionProvider.class));
+      backend.setConnectionPoolSettings(new ConnectionPoolSettings()
+         .withInitialPoolSize(2)
+         .withAcquireIncrement(1)
+         .withMinPoolSize(1)
+         .withMaxPoolSize(4)
+         .withCheckoutTimeoutSeconds(1));
+      QContext.init(qInstance, new QSession());
+
+      /////////////////////////
+      // assert initial size //
+      /////////////////////////
+      new QueryAction().execute(new QueryInput(TestUtils.TABLE_NAME_PERSON));
+      JSONObject debugValues = getDebugStateValues(true);
+      assertThat(debugValues.getInt("numConnections")).isEqualTo(2);
+
+      ///////////////////////////////////////////////////////////////////////
+      // open (and close) 5 conns - shouldn't get bigger than initial size //
+      ///////////////////////////////////////////////////////////////////////
+      for(int i = 0; i < 5; i++)
+      {
+         new QueryAction().execute(new QueryInput(TestUtils.TABLE_NAME_PERSON));
+      }
+      debugValues = getDebugStateValues(true);
+      assertThat(debugValues.getInt("numConnections")).isBetween(2, 4); // due to potential timing issues, sometimes pool will acquire 1 or 2 more, so, this seems ok
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // open up 4 transactions - confirm the pool opens some new conns, but stops at the max, and throws based on checkoutTimeout setting //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      List<QBackendTransaction> transactions = new ArrayList<>();
+      for(int i = 0; i < 5; i++)
+      {
+         if(i == 4)
+         {
+            //////////////////////////////////////////
+            // expect this one to fail - full pool! //
+            //////////////////////////////////////////
+            assertThatThrownBy(() -> QBackendTransaction.openFor(new InsertInput(TestUtils.TABLE_NAME_PERSON)))
+               .hasRootCauseInstanceOf(TimeoutException.class);
+         }
+         else
+         {
+            transactions.add(QBackendTransaction.openFor(new InsertInput(TestUtils.TABLE_NAME_PERSON)));
+         }
+      }
+
+      debugValues = getDebugStateValues(true);
+      assertThat(debugValues.getInt("numConnections")).isEqualTo(4);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static JSONObject getDebugStateValues(boolean printIt)
+   {
+      JSONArray debugArray = ConnectionManager.dumpConnectionProviderDebug();
+      for(int i = 0; i < debugArray.length(); i++)
+      {
+         JSONObject object = debugArray.getJSONObject(i);
+         if(TestUtils.DEFAULT_BACKEND_NAME.equals(object.optString("backendName")))
+         {
+            JSONObject values = object.getJSONObject("values");
+            if(printIt)
+            {
+               System.out.println(values.toString(3));
+            }
+
+            JSONObject state = values.getJSONObject("state");
+            return state;
+         }
+      }
+
+      fail("Didn't find debug values...");
+      return (null);
+   }
+
+}

qqq-backend-module-rdbms/src/test/java/com/kingsrook/qqq/backend/module/rdbms/jdbc/QueryManagerTest.java

@@ -64,7 +64,8 @@ class QueryManagerTest extends BaseTest
    @BeforeEach
    void beforeEach() throws SQLException
    {
-      Connection connection = getConnection();
+      try(Connection connection = getConnection())
+      {
          QueryManager.executeUpdate(connection, """
             CREATE TABLE test_table
             (
@@ -77,6 +78,7 @@ class QueryManagerTest extends BaseTest
             )
             """);
       }
+   }
 
 
 
@@ -86,9 +88,11 @@ class QueryManagerTest extends BaseTest
    @AfterEach
    void afterEach() throws SQLException
    {
-      Connection connection = getConnection();
+      try(Connection connection = getConnection())
+      {
          QueryManager.executeUpdate(connection, "DROP TABLE test_table");
       }
+   }
 
 
 
@@ -108,9 +112,10 @@ class QueryManagerTest extends BaseTest
     *******************************************************************************/
    @Test
    void testBindParams() throws SQLException
+   {
+      try(Connection connection = getConnection())
       {
          long              ctMillis = System.currentTimeMillis();
-      Connection        connection = getConnection();
          PreparedStatement ps       = connection.prepareStatement("UPDATE test_table SET int_col = ? WHERE int_col > 0");
 
          ///////////////////////////////////////////////////////////////////////////////
@@ -160,6 +165,7 @@ class QueryManagerTest extends BaseTest
          // originally longs were being downgraded to int when binding, so, verify that doesn't happen //
          ////////////////////////////////////////////////////////////////////////////////////////////////
       }
+   }
 
 
 
@@ -168,10 +174,11 @@ class QueryManagerTest extends BaseTest
     *******************************************************************************/
    @Test
    void testLongBinding() throws SQLException
+   {
+      try(Connection connection = getConnection())
       {
          Long biggerThanMaxInteger = 2147483648L;
 
-      Connection        connection = getConnection();
          PreparedStatement ps = connection.prepareStatement("INSERT INTO test_table (long_col) VALUES (?)");
          QueryManager.bindParam(ps, 1, biggerThanMaxInteger);
          ps.execute();
@@ -183,6 +190,7 @@ class QueryManagerTest extends BaseTest
          assertTrue(rs.next());
          assertEquals(biggerThanMaxInteger, QueryManager.getLong(rs, "long_col"));
       }
+   }
 
 
 
@@ -191,10 +199,11 @@ class QueryManagerTest extends BaseTest
     *******************************************************************************/
    @Test
    void testGetValueMethods() throws SQLException
+   {
+      try(Connection connection = getConnection())
       {
          Long biggerThanMaxInteger = 2147483648L;
 
-      Connection connection = getConnection();
          QueryManager.executeUpdate(connection, "INSERT INTO test_table (int_col, datetime_col, char_col, long_col) VALUES (1, now(), 'A', " + biggerThanMaxInteger + ")");
          PreparedStatement preparedStatement = connection.prepareStatement("SELECT int_col, datetime_col, char_col, long_col from test_table");
          preparedStatement.execute();
@@ -230,6 +239,7 @@ class QueryManagerTest extends BaseTest
          assertEquals(biggerThanMaxInteger, QueryManager.getLong(rs, "long_col"));
          assertEquals(biggerThanMaxInteger, QueryManager.getLong(rs, 4));
       }
+   }
 
 
 
@@ -239,7 +249,8 @@ class QueryManagerTest extends BaseTest
    @Test
    void testGetValueMethodsReturningNull() throws SQLException
    {
-      Connection connection = getConnection();
+      try(Connection connection = getConnection())
+      {
          QueryManager.executeUpdate(connection, "INSERT INTO test_table (int_col, datetime_col, char_col) VALUES (null, null, null)");
          PreparedStatement preparedStatement = connection.prepareStatement("SELECT * from test_table");
          preparedStatement.execute();
@@ -273,6 +284,7 @@ class QueryManagerTest extends BaseTest
          assertNull(QueryManager.getObject(rs, "char_col"));
          assertNull(QueryManager.getObject(rs, 3));
       }
+   }
 
 
 
@@ -283,7 +295,8 @@ class QueryManagerTest extends BaseTest
    @Test
    void testLocalDate() throws SQLException
    {
-      Connection connection = getConnection();
+      try(Connection connection = getConnection())
+      {
          QueryManager.executeUpdate(connection, "INSERT INTO test_table (date_col) VALUES (?)", LocalDate.of(2013, Month.OCTOBER, 1));
 
          PreparedStatement preparedStatement = connection.prepareStatement("SELECT date_col from test_table");
@@ -315,6 +328,7 @@ class QueryManagerTest extends BaseTest
          assertEquals(0, offsetDateTime.getHour(), "Hour value");
          assertEquals(0, offsetDateTime.getMinute(), "Minute value");
       }
+   }
 
 
 
@@ -324,8 +338,8 @@ class QueryManagerTest extends BaseTest
    @Test
    void testLocalTime() throws SQLException
    {
-      Connection connection = getConnection();
+      try(Connection connection = getConnection())
-
+      {
          ////////////////////////////////////
          // insert one just hour & minutes //
          ////////////////////////////////////
@@ -366,6 +380,7 @@ class QueryManagerTest extends BaseTest
          assertEquals(42, localTime.getMinute(), "Minute value");
          assertEquals(59, localTime.getSecond(), "Second value");
       }
+   }
 
 
 
@@ -375,7 +390,8 @@ class QueryManagerTest extends BaseTest
    @Test
    void testExecuteStatementForSingleValue() throws SQLException
    {
-      Connection connection = getConnection();
+      try(Connection connection = getConnection())
+      {
          QueryManager.executeUpdate(connection, """
             INSERT INTO test_table
             ( int_col, datetime_col, char_col, date_col, time_col )
@@ -397,6 +413,7 @@ class QueryManagerTest extends BaseTest
             """);
          assertEquals(null, QueryManager.executeStatementForSingleValue(connection, Integer.class, "SELECT int_col FROM test_table WHERE int_col IS NULL"));
       }
+   }
 
 
 
@@ -406,7 +423,8 @@ class QueryManagerTest extends BaseTest
    @Test
    void testQueryForSimpleEntity() throws SQLException
    {
-      Connection connection = getConnection();
+      try(Connection connection = getConnection())
+      {
          QueryManager.executeUpdate(connection, """
             INSERT INTO test_table
             ( int_col, datetime_col, char_col, date_col, time_col )
@@ -418,6 +436,7 @@ class QueryManagerTest extends BaseTest
          assertEquals(47, simpleEntity.get("INT_COL"));
          assertEquals("Q", simpleEntity.get("CHAR_COL"));
       }
+   }
 
 
 
@@ -427,7 +446,8 @@ class QueryManagerTest extends BaseTest
    @Test
    void testQueryForRows() throws SQLException
    {
-      Connection connection = getConnection();
+      try(Connection connection = getConnection())
+      {
          QueryManager.executeUpdate(connection, """
             INSERT INTO test_table
             ( int_col, datetime_col, char_col, date_col, time_col )
@@ -439,5 +459,6 @@ class QueryManagerTest extends BaseTest
          assertEquals(47, rows.get(0).get("INT_COL"));
          assertEquals("Q", rows.get(0).get("CHAR_COL"));
       }
+   }
 
 }

qqq-middleware-api/src/main/java/com/kingsrook/qqq/api/actions/ApiImplementation.java

@@ -76,6 +76,7 @@ import com.kingsrook.qqq.backend.core.model.actions.processes.ProcessState;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessInput;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.QInputSource;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
@@ -160,6 +161,7 @@ public class ApiImplementation
       queryInput.setTableName(tableName);
       queryInput.setIncludeAssociations(true);
       queryInput.setShouldFetchHeavyFields(true);
+      queryInput.withQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
 
       PermissionsHelper.checkTablePermissionThrowing(queryInput, TablePermissionSubType.READ);
 
@@ -394,6 +396,7 @@ public class ApiImplementation
          CountInput countInput = new CountInput();
          countInput.setTableName(tableName);
          countInput.setFilter(filter);
+         countInput.withQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
          CountOutput countOutput = new CountAction().execute(countInput);
          output.put("count", countOutput.getCount());
       }
@@ -595,6 +598,7 @@ public class ApiImplementation
 
       GetInput getInput = new GetInput();
       getInput.setTableName(tableName);
+      getInput.withQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
 
       PermissionsHelper.checkTablePermissionThrowing(getInput, TablePermissionSubType.READ);
 

qqq-middleware-javalin/src/main/java/com/kingsrook/qqq/backend/javalin/QJavalinImplementation.java

@@ -82,6 +82,7 @@ import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportOutput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportDestination;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportFormat;
 import com.kingsrook.qqq.backend.core.model.actions.tables.QInputSource;
+import com.kingsrook.qqq.backend.core.model.actions.tables.QueryHint;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
@@ -1195,6 +1196,7 @@ public class QJavalinImplementation
          countInput.setTimeoutSeconds(DEFAULT_COUNT_TIMEOUT_SECONDS);
          countInput.setQueryJoins(processQueryJoinsParam(context));
          countInput.setIncludeDistinctCount(QJavalinUtils.queryParamIsTrue(context, "includeDistinct"));
+         countInput.withQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
 
          CountAction countAction = new CountAction();
          CountOutput countOutput = countAction.execute(countInput);
@@ -1250,6 +1252,7 @@ public class QJavalinImplementation
          queryInput.setShouldGenerateDisplayValues(true);
          queryInput.setShouldTranslatePossibleValues(true);
          queryInput.setTimeoutSeconds(DEFAULT_QUERY_TIMEOUT_SECONDS);
+         queryInput.withQueryHint(QueryHint.MAY_USE_READ_ONLY_BACKEND);
 
          PermissionsHelper.checkTablePermissionThrowing(queryInput, TablePermissionSubType.READ);
 

qqq-middleware-javalin/src/test/java/com/kingsrook/qqq/backend/javalin/TestUtils.java

@@ -114,7 +114,9 @@ public class TestUtils
    public static void primeTestDatabase() throws Exception
    {
       ConnectionManager connectionManager = new ConnectionManager();
-      Connection        connection                 = connectionManager.getConnection(TestUtils.defineDefaultH2Backend());
+
+      try(Connection connection = connectionManager.getConnection(TestUtils.defineDefaultH2Backend()))
+      {
          InputStream primeTestDatabaseSqlStream = TestUtils.class.getResourceAsStream("/prime-test-database.sql");
          assertNotNull(primeTestDatabaseSqlStream);
          List<String> lines = (List<String>) IOUtils.readLines(primeTestDatabaseSqlStream);
@@ -125,6 +127,7 @@ public class TestUtils
             QueryManager.executeUpdate(connection, sql);
          }
       }
+   }
 
 
 
@@ -135,9 +138,11 @@ public class TestUtils
    public static void runTestSql(String sql, QueryManager.ResultSetProcessor resultSetProcessor) throws Exception
    {
       ConnectionManager connectionManager = new ConnectionManager();
-      Connection        connection        = connectionManager.getConnection(defineDefaultH2Backend());
+      try(Connection connection = connectionManager.getConnection(defineDefaultH2Backend()))
+      {
          QueryManager.executeStatement(connection, sql, resultSetProcessor);
       }
+   }
 
 
 

qqq-middleware-picocli/src/test/java/com/kingsrook/qqq/frontend/picocli/TestUtils.java

@@ -61,7 +61,8 @@ public class TestUtils
    public static void primeTestDatabase() throws Exception
    {
       ConnectionManager connectionManager = new ConnectionManager();
-      Connection        connection                 = connectionManager.getConnection(TestUtils.defineBackend());
+      try(Connection connection = connectionManager.getConnection(TestUtils.defineBackend()))
+      {
          InputStream primeTestDatabaseSqlStream = TestUtils.class.getResourceAsStream("/prime-test-database.sql");
          assertNotNull(primeTestDatabaseSqlStream);
          List<String> lines = (List<String>) IOUtils.readLines(primeTestDatabaseSqlStream);
@@ -72,6 +73,7 @@ public class TestUtils
             QueryManager.executeUpdate(connection, sql);
          }
       }
+   }
 
 
 
@@ -82,9 +84,11 @@ public class TestUtils
    public static void runTestSql(String sql, QueryManager.ResultSetProcessor resultSetProcessor) throws Exception
    {
       ConnectionManager connectionManager = new ConnectionManager();
-      Connection        connection        = connectionManager.getConnection(defineBackend());
+      try(Connection connection = connectionManager.getConnection(defineBackend()))
+      {
          QueryManager.executeStatement(connection, sql, resultSetProcessor);
       }
+   }