Apply PQgetRowData()

Author: markokr

doc/src/sgml/libpq.sgml

@@ -4059,6 +4059,34 @@ int PQsetSingleRowMode(PGconn *conn);
      </listitem>
     </varlistentry>
 
+    <varlistentry id="libpq-pqgetrowdata">
+     <term>
+      <function>PQgetRowData</function>
+      <indexterm>
+       <primary>PQgetRowData</primary>
+      </indexterm>
+     </term>
+
+     <listitem>
+      <para>
+       In single row mode it is possible to get row data directly,
+       without constructing <structname>PGresult</structname> for
+       each row.
+
+<synopsis>
+int PQgetRowData(PGconn *conn, PGresult **hdr, PGdataValue **columns);
+</synopsis>
+      </para>
+
+      <para>
+       It can be called everywhere <function>PQgetResult</function> can.
+       It returns 1 and fills pointers if there is row data avilable.
+       It returns 0 otherwise.  Then <function>PQgetResult</function>
+       should be called to get final status.
+      </para>
+     </listitem>
+    </varlistentry>
+
    </variablelist>
   </para>
 

src/interfaces/libpq/exports.txt

@@ -161,3 +161,4 @@ PQping                    158
 PQpingParams              159
 PQlibVersion              160
 PQsetSingleRowMode        161
+PQgetRowData              162

src/interfaces/libpq/fe-exec.c

@@ -1554,6 +1554,75 @@ pqSingleRowResult(PGconn *conn)
 	return pqPrepareAsyncResult(conn);
 }
 
+/*
+ * Get raw row data from network buffer.
+ *
+ * It duplicates the flush/read logic of PQgetResult() to be able
+ * to work on sync connection.  It does not return any error state,
+ * instead it leaves that to actual PQgetResult().
+ *
+ *		Returns: 1 - have row data, 0 - do not have it
+ */
+int
+PQgetRowData(PGconn *conn, PGresult **hdrp, PGdataValue **cols)
+{
+	if (!conn)
+		return 0;
+
+	/* Parse any available data, if our state permits. */
+	parseInput(conn);
+
+	/* If not ready to return something, block until we are. */
+	while (conn->asyncStatus == PGASYNC_BUSY)
+	{
+		int			flushResult;
+
+		/*
+		 * If data remains unsent, send it.  Else we might be waiting for the
+		 * result of a command the backend hasn't even got yet.
+		 */
+		while ((flushResult = pqFlush(conn)) > 0)
+		{
+			if (pqWait(FALSE, TRUE, conn))
+			{
+				flushResult = -1;
+				break;
+			}
+		}
+
+		/* Wait for some more data, and load it. */
+		if (flushResult ||
+			pqWait(TRUE, FALSE, conn) ||
+			pqReadData(conn) < 0)
+		{
+			/*
+			 * conn->errorMessage has been set by pqWait or pqReadData. We
+			 * want to append it to any already-received error message.
+			 */
+			pqSaveErrorResult(conn);
+
+			/* Make PQgetResult() return the error */
+			conn->asyncStatus = PGASYNC_READY;
+			break;
+		}
+
+		/* Parse it. */
+		parseInput(conn);
+	}
+
+	/* should PQgetResult() be called instead? */
+	if (conn->asyncStatus != PGASYNC_ROW_READY)
+		return 0;
+
+	/* allow parsing to proceed */
+	conn->asyncStatus = PGASYNC_BUSY;
+
+	/* return pointers to current row */
+	*hdrp = conn->result;
+	*cols = conn->rowBuf;
+	return 1;
+}
+
 /*
  * Consume any available input from the backend
  * 0 return: some kind of trouble

src/interfaces/libpq/libpq-fe.h

@@ -130,6 +130,17 @@ typedef struct pg_conn PGconn;
  */
 typedef struct pg_result PGresult;
 
+/* PGdataValue represents a data field value being passed to a row processor.
+ * It could be either text or binary data; text data is not zero-terminated.
+ * A SQL NULL is represented by len < 0; then value is still valid but there
+ * are no data bytes there.
+ */
+typedef struct pgDataValue
+{
+	int			len;			/* data length in bytes, or <0 if NULL */
+	const char *value;			/* data value, without zero-termination */
+} PGdataValue;
+
 /* PGcancel encapsulates the information needed to cancel a running
  * query on an existing connection.
  * The contents of this struct are not supposed to be known to applications.
@@ -392,6 +403,7 @@ extern int PQsendQueryPrepared(PGconn *conn,
 extern PGresult *PQgetResult(PGconn *conn);
 
 extern int PQsetSingleRowMode(PGconn *conn);
+extern int PQgetRowData(PGconn *conn, PGresult **hdrp, PGdataValue **columns);
 
 /* Routines for managing an asynchronous query */
 extern int	PQisBusy(PGconn *conn);

src/interfaces/libpq/libpq-int.h

@@ -278,17 +278,6 @@ typedef struct pgLobjfuncs
 	Oid			fn_lo_write;	/* OID of backend function LOwrite		*/
 } PGlobjfuncs;
 
-/* PGdataValue represents a data field value being passed to a row processor.
- * It could be either text or binary data; text data is not zero-terminated.
- * A SQL NULL is represented by len < 0; then value is still valid but there
- * are no data bytes there.
- */
-typedef struct pgDataValue
-{
-	int			len;			/* data length in bytes, or <0 if NULL */
-	const char *value;			/* data value, without zero-termination */
-} PGdataValue;
-
 /*
  * PGconn stores all the state data associated with a single connection
  * to a backend.