Updated qury path for better rate limiting.

Added post-request check for prepared statement in queries
to enable calls to rate limiters if none were set previously.
Also updated QueryRequest.doesWrites() to check for SELECT
vs other query types.

Author: connelly38

driver/src/main/java/oracle/nosql/driver/http/Client.java

@@ -536,6 +536,13 @@ public Result execute(Request kvRequest) {
                     updateRateLimiters(((TableResult)res).getTableName(), tl);
                 }
 
+                if (rateLimiterMap != null && readLimiter == null) {
+                    readLimiter = getQueryRateLimiter(kvRequest, true);
+                }
+                if (rateLimiterMap != null && writeLimiter == null) {
+                    writeLimiter = getQueryRateLimiter(kvRequest, false);
+                }
+
                 /* consume rate limiter units based on actual usage */
                 rateDelayedMs += consumeLimiterUnits(readLimiter,
                                     res.getReadUnitsInternal(),
@@ -697,6 +704,40 @@ public Result execute(Request kvRequest) {
             kvRequest.getRetryStats(), exception);
     }
 
+    /**
+     * Returns a rate limiter for a query operation, if the query op has
+     * a prepared statement and a limiter exists in the rate limiter map
+     * for the query table.
+     */
+    private RateLimiter getQueryRateLimiter(Request request, boolean read) {
+        if (rateLimiterMap == null || !(request instanceof QueryRequest)) {
+            return null;
+        }
+
+        /*
+         * If we're asked for a write limiter, and the request doesn't
+         * do writes, return null
+         */
+        if (read == false && ((QueryRequest)request).doesWrites() == false) {
+            return null;
+        }
+
+        /*
+         * We sometimes may only get a prepared statement after the
+         * first query response is returned. In this case, we can get
+         * the tablename from the request and apply rate limiting.
+         */
+        String tableName = ((QueryRequest)request).getTableName();
+        if (tableName == null || tableName == "") {
+            return null;
+        }
+
+        if (read) {
+            return rateLimiterMap.getReadLimiter(tableName);
+        }
+        return rateLimiterMap.getWriteLimiter(tableName);
+    }
+
 
     /**
      * Comsume rate limiter units after successful operation.

driver/src/main/java/oracle/nosql/driver/ops/PreparedStatement.java

@@ -85,14 +85,22 @@ public class PreparedStatement {
     /*
      * The namespace returned from a prepared query result, if any.
      */
-    private String namespace;
+    private final String namespace;
 
 
     /*
      * The table name returned from a prepared query result, if any.
      */
-    private String tableName;
+    private final String tableName;
 
+    /*
+     * the operation code for the query.
+     */
+    private final byte operation;
+
+    /* The one operation code we care about */
+    /* "5" == PrepareCallback.QueryOperation.SELECT */
+    private final byte OPCODE_SELECT = 5;
 
     /**
      * @hidden
@@ -111,6 +119,7 @@ public class PreparedStatement {
      * @param externalVars external variables for the query
      * @param namespace namespace, if any, from deserialization
      * @param tableName table name, if any, from deserialization
+     * @param operation operation code for the query
      */
     public PreparedStatement(
         String sqlText,
@@ -122,7 +131,8 @@ public PreparedStatement(
         int numRegisters,
         Map<String, Integer> externalVars,
         String namespace,
-        String tableName) {
+        String tableName,
+        byte operation) {
 
         /* 10 is arbitrary. TODO: put magic number in it for validation? */
         if (proxyStatement == null || proxyStatement.length < 10) {
@@ -140,6 +150,7 @@ public PreparedStatement(
         this.variables = externalVars;
         this.namespace = namespace;
         this.tableName = tableName;
+        this.operation = operation;
     }
 
     /**
@@ -160,7 +171,8 @@ public PreparedStatement copyStatement() {
                                      numRegisters,
                                      variables,
                                      namespace,
-                                     tableName);
+                                     tableName,
+                                     operation);
     }
 
     /**
@@ -378,4 +390,13 @@ public String getNamespace() {
     public String getTableName() {
         return tableName;
     }
+
+    /**
+     * @hidden
+     * @return true if the query does writes
+     */
+    public boolean doesWrites() {
+        /* if it's not SELECT, it does writes */
+        return operation != OPCODE_SELECT;
+    }
 }

driver/src/main/java/oracle/nosql/driver/ops/QueryRequest.java

@@ -212,9 +212,7 @@ public boolean isQueryRequest() {
     @Override
     public boolean doesReads() {
         /*
-         * Currently there is no easy/dependable mechanism to tell if
-         * a query will do reads or writes. So we assume the most likely
-         * case. TODO: update this when we have better info
+         * Just about every permutation of query does reads
          */
         return true;
     }
@@ -224,12 +222,10 @@ public boolean doesReads() {
      */
     @Override
     public boolean doesWrites() {
-        /*
-         * Currently there is no easy/dependable mechanism to tell if
-         * a query will do reads or writes. So we assume the most likely
-         * case. TODO: update this when we have better info
-         */
-        return false;
+        if (preparedStatement == null) {
+            return false;
+        }
+        return preparedStatement.doesWrites();
     }
 
     /**

driver/src/main/java/oracle/nosql/driver/ops/serde/PrepareRequestSerializer.java

@@ -80,11 +80,13 @@ static PreparedStatement deserializeInternal(
          * byte (number of tables)
          * namespace (string)
          * tablename (string)
+         * operation (1 byte)
          */
         int savedOffset = in.getOffset();
         in.skip(37); // 4 + 32 + 1
         String namespace = readString(in);
         String tableName = readString(in);
+        byte operation = in.readByte();
         in.setOffset(savedOffset);
 
         byte[] proxyStatement = readByteArrayWithInt(in);
@@ -129,6 +131,7 @@ static PreparedStatement deserializeInternal(
                                      numRegisters,
                                      externalVars,
                                      namespace,
-                                     tableName);
+                                     tableName,
+                                     operation);
     }
 }