readlob with length and offset

Author: gamecube7561

src/rwl.h

@@ -13,6 +13,7 @@
  *
  * History
  *
+ * johnkenn 18-dec-2023 - Lob size and offset for streaming
  * bengsig   9-nov-2023 - Increase RWL_MAX_VAR
  * johnkenn 02-nov-2023 - trignometry sin, cos, atan2
  * bengsig   3-oct-2023 - Now development for 3.1.1
@@ -858,6 +859,12 @@ struct rwl_main
   sb4 filvarn; /* fine variable number for write/writeline */
   text *lobnam; /* LOB variable name for readlob/rwitelob */
   sb4 lobvarn; /* LOB variable number for readlob/rwitelob */
+  text *lobwritenam;
+  sb4 lobwritevarn;
+  text *loblengthnam;
+  sb4 loblengthvarn;
+  rwl_estack *loboffset;  /* LOB offset to start at for data stream */
+  
   rwl_sql *sqsav; /* temporary save of sql */
   sb4 sqsavvarn; // and its variable number
   rwl_cinfo *dbsav; /* temporary save of db (cinfo) used during database declaration */
@@ -1493,6 +1500,7 @@ enum rwl_code_t
 , RWL_CODE_GETRUSAGE // call rwlgetrusage - no args
 , RWL_CODE_RETURN // return statement - ceptr1/ceint2 is name/guess of procedure/function where return is from
 , RWL_CODE_READLOB // Read a LOB into a string - ceptr1/ceint2 is name/guess of LOB, ceptr3/ceint4 of string variable
+, RWL_CODE_READLOB_LO // Read a LOB into a string with offset and read length - ceptr5 of int - ceptr of int
 , RWL_CODE_WRITELOB // Write a LOB from an expression - ceptr1/ceint2 is name/guess of LOB, ceptr3 is rwl_estack* to write to it
 // control control block execution does not nest
 , RWL_CODE_CBLOCK_BEG // Begin of control block - no arguments
@@ -1698,6 +1706,7 @@ extern void rwlcodeadd(rwl_main *, rwl_code_t, void *, ub4 , void *, ub4, void *
  * - a u means an ub4 (well, it really is sb4)
  * -   x means ignored arg
  */
+#define rwlcodeaddpupupup(rwlp,ctype,parg1,arg2,parg3,arg4,parg5,arg6,parg7) rwlcodeadd(rwlp,ctype,parg1,arg2,parg3,arg4,parg5,arg6,parg7)
 #define rwlcodeaddpupupu(rwlp,ctype,parg1,arg2,parg3,arg4,parg5,arg6) rwlcodeadd(rwlp,ctype,parg1,arg2,parg3,arg4,parg5,arg6,0) 
 #define rwlcodeaddpuppp(rwlp,ctype,parg1,arg2,parg3,parg5,parg7) rwlcodeadd(rwlp,(ctype),parg1,arg2,parg3,0,parg5,0,parg7) 
 #define rwlcodeaddpupp(rwlp,ctype,parg1,arg2,parg3,parg5) rwlcodeadd(rwlp,ctype,parg1,arg2,parg3,0,parg5,0,0) 
@@ -1834,6 +1843,7 @@ extern void rwlalloclob(rwl_xeqenv *, rwl_location *, OCILobLocator **);
 extern void rwlfreelob(rwl_xeqenv *, rwl_location *, OCILobLocator *);
 extern void rwlwritelob(rwl_xeqenv *, OCILobLocator *, rwl_cinfo *, rwl_value *, rwl_location *, text *);
 extern void rwlreadlob(rwl_xeqenv *, OCILobLocator *, rwl_cinfo *, rwl_value *, rwl_location *, text *);
+extern void rwlreadloblo(rwl_xeqenv *, OCILobLocator *, rwl_cinfo *, rwl_value *, rwl_value *, ub8, rwl_location *, text *);
 extern void rwldummyonbad(rwl_xeqenv *, text *); // Use dummy database if default is bad
 extern ub4 rwldebugconv(rwl_main *,text *);
 

src/rwlcodeadd.c

@@ -13,6 +13,7 @@
  *
  * History
  *
+ * johnkenn 18-dec-2023 - readlob length offset
  * bengsig  20-sep-2023 - list iterator loop
  * bengsig  10-aug-2023 - session pool timeout then action
  * bengsig  15-may-2023 - statisticsonly, incorrect RWL-239
@@ -132,6 +133,7 @@ void rwlcodeadd(rwl_main *rwm, rwl_code_t ctype, void *parg1
     case RWL_CODE_DYNSREL:    rwm->code[rwm->ccount].cname = "dqrel"; break;
     case RWL_CODE_DYNBINDEF:  rwm->code[rwm->ccount].cname = "dqbd"; break;
     case RWL_CODE_READLOB:    rwm->code[rwm->ccount].cname = "rdlob"; break;
+    case RWL_CODE_READLOB_LO:    rwm->code[rwm->ccount].cname = "rdloblo"; break;
     case RWL_CODE_WRITELOB:    rwm->code[rwm->ccount].cname = "wrlob"; break;
     case RWL_CODE_REGEX:    rwm->code[rwm->ccount].cname = "regex"; break;
     case RWL_CODE_REGEXTRACT:    rwm->code[rwm->ccount].cname = "reext"; break;
@@ -613,7 +615,16 @@ void rwlcodeadd(rwl_main *rwm, rwl_code_t ctype, void *parg1
       rwm->code[rwm->ccount].ceint2 = (sb4) arg2; // guess of lob var#
       rwm->code[rwm->ccount].ceptr3 = parg3; // string name
       rwm->code[rwm->ccount].ceint4 = (sb4) arg4; // guess of string var#
-      rwm->code[rwm->ccount].ceptr5 = parg5; // codename
+    break;
+
+    case RWL_CODE_READLOB_LO:
+      rwm->code[rwm->ccount].ceptr1 = parg1; // lob name
+      rwm->code[rwm->ccount].ceint2 = (sb4) arg2; // guess of lob var#
+      rwm->code[rwm->ccount].ceptr3 = parg3; // string name
+      rwm->code[rwm->ccount].ceint4 = (sb4) arg4; // guess of string var#
+      rwm->code[rwm->ccount].ceptr5 = parg5; // int name
+      rwm->code[rwm->ccount].ceint6 = (sb4) arg6; // guess of int var#
+      rwm->code[rwm->ccount].ceptr7 = parg7; // expression
     break;
 
     case RWL_CODE_WRITELOB:

src/rwlcoderun.c

@@ -14,6 +14,7 @@
  *
  * History
  *
+ * johnkenn 18-dec-2023 - Add lobstreaming to readlob
  * bengsig  25-sep-2023 - fix if doublevar then
  * bengsig  22-sep-2023 - ampersand needs thread local sql
  * bengsig  20-sep-2023 - list iterator loop
@@ -1145,6 +1146,7 @@ void *rwlcoderun ( rwl_xeqenv *xev)
 	  // and the string
 	  l2 = rwlfindvarug2(xev, xev->rwm->code[pc].ceptr3, &xev->rwm->code[pc].ceint4
 	    , codename);
+
 	  /*assert*/
 	  if (xev->evar[l].vtype != RWL_TYPE_CLOB
 	   && xev->evar[l].vtype != RWL_TYPE_BLOB)
@@ -1171,6 +1173,58 @@ void *rwlcoderun ( rwl_xeqenv *xev)
 	}
       break;
 
+			case RWL_CODE_READLOB_LO:
+	{
+		sb4 l, l2, l3; 
+		if (bit(xev->rwm->mflags, RWL_DEBUG_EXECUTE))
+	    	rwldebug(xev->rwm, "pc=%d executing readlob_lo", pc);
+		// find the LOB
+		l = rwlfindvarug2(xev, xev->rwm->code[pc].ceptr1, &xev->rwm->code[pc].ceint2
+			, codename);
+		// and the string
+		l2 = rwlfindvarug2(xev, xev->rwm->code[pc].ceptr3, &xev->rwm->code[pc].ceint4
+			, codename);
+		// and the length int
+		l3 = rwlfindvarug2(xev, xev->rwm->code[pc].ceptr5, &xev->rwm->code[pc].ceint6
+			, codename);
+		/* evaluate the offset expression */
+		rwlexpreval(xev->rwm->code[pc].ceptr7, &xev->rwm->code[pc].cloc, xev, &xev->xqnum);
+		/*assert*/
+	  if (xev->evar[l].vtype != RWL_TYPE_CLOB
+	   && xev->evar[l].vtype != RWL_TYPE_BLOB)
+	  {
+	    rwlexecsevere(xev, &xev->rwm->code[pc].cloc
+	      , "[rwlcoderun-readlob1:%s;%s;%d]", xev->evar[l].vname, xev->evar[l].stype, l);
+	  }
+	  else if (xev->evar[l2].vtype != RWL_TYPE_STR)
+	  {
+	    rwlexecsevere(xev, &xev->rwm->code[pc].cloc
+	      , "[rwlcoderun-readlob2:%s;%s;%d]", xev->evar[l2].vname, xev->evar[l2].stype, l2);
+	  }
+		else if (xev->evar[l3].vtype != RWL_TYPE_INT)
+		{
+			    rwlexecsevere(xev, &xev->rwm->code[pc].cloc
+	      , "[rwlcoderun-readlob2:%s;%s;%d]", xev->evar[l3].vname, xev->evar[l3].stype, l3);	
+		}
+	  else
+	  {
+	    rwl_identifier *ri = rwlidgetmx(xev, &xev->rwm->code[pc].cloc, l2);
+			rwl_identifier *ri2 = rwlidgetmx(xev, &xev->rwm->code[pc].cloc, l3);
+	    rwlreadloblo(xev
+	      , rwlnuminvar(xev, xev->evar+l)->vptr // the OCILob *
+	      , xev->evar[l].vdata     	// the db (i.e. rwl_cinfo *)
+	      , rwlnuminvar(xev, ri)    // the string to read into
+				, rwlnuminvar(xev, ri2)		// the int to read the length from
+				, (ub8) xev->xqnum.ival		// offset value
+	      , &xev->rwm->code[pc].cloc
+				, codename);
+	    rwlidrelmx(xev, &xev->rwm->code[pc].cloc, l2);
+			rwlidrelmx(xev, &xev->rwm->code[pc].cloc, l3);
+	  }
+		pc++;
+	}
+	  	break;
+
       case RWL_CODE_STACK:
 	{
 	  if (bit(xev->rwm->mflags, RWL_DEBUG_EXECUTE))

src/rwlparser.y

@@ -2972,63 +2972,20 @@ statement:
 	    }
 	  }
 
-	| RWL_T_READLOB { bis(rwm->m2flags, RWL_P2_MAYBECOMMAW); } RWL_T_IDENTIFIER maybecomma
-          {
-            sb4 l;
-            rwm->lobvarn = RWL_VAR_NOTFOUND;
-	    rwm->lobnam = (yychar == RWL_T_IDENTIFIER)
-	      ? rwm->previnam
-	      : rwm->inam;
-	    if (bit(rwm->m2flags, RWL_P2_MAYBECOMMAW))
-	      rwlerror(rwm, RWL_ERROR_COMMA_IS_RECOMMENDED, rwm->lobnam, "readlob");
-            /* lookup the file and check it is a lob */
-            l = rwlfindvar2(rwm->mxq, rwm->lobnam, RWL_VAR_NOGUESS, rwm->codename);
-            if (l>=0)
-            {
-              switch (rwm->mxq->evar[l].vtype)
-              {
-                case RWL_TYPE_BLOB:
-                case RWL_TYPE_CLOB:
-                  rwm->lobvarn = l;
-                break;
-
-                default:
-                  rwlerror(rwm,RWL_ERROR_INCORRECT_TYPE2, rwm->mxq->evar[l].stype, rwm->lobnam, "lob");
-                break;
-              }
-            }
-	  }
-	  RWL_T_IDENTIFIER terminator
-	  {
-            sb4 l;
-            /* lookup the variable and check it is a string */
-            l = rwlfindvar2(rwm->mxq, rwm->inam, RWL_VAR_NOGUESS, rwm->codename);
-            if (l>=0)
-            {
-              switch (rwm->mxq->evar[l].vtype)
-              {
-                case RWL_TYPE_STR:
-		  if (rwm->codename)
-		    rwlcodeaddpupu(rwm, RWL_CODE_READLOB
-		      , rwm->lobnam, rwm->lobvarn, rwm->inam, l);
-		  else
-		  if (!bit(rwm->m2flags, RWL_P2_NOEXEC))
-		  {
-		    if (rwm->maindb)
-		      rwlreadlob(rwm->mxq, rwm->mxq->evar[rwm->lobvarn].num.vptr, rwm->maindb
-		      , &rwm->mxq->evar[l].num, &rwm->loc, 0);
-		    else
-		      rwlerror(rwm, RWL_ERROR_NOT_DONE_IN_MAIN, "readlob");
-		  }
-                break;
-
-                default:
-                  rwlerror(rwm,RWL_ERROR_INCORRECT_TYPE2
-		    , rwm->mxq->evar[l].stype, rwm->inam, "string");
-                break;
-              }
-            }
-	  } 
+| RWL_T_READLOB readlobhead maybereadlobtail terminator
+		{
+			if (rwm->loblengthvarn && rwm->loboffset)
+			{
+				
+				rwlcodeaddpupupup(rwm, RWL_CODE_READLOB_LO, rwm->lobnam, rwm->lobvarn, 
+				rwm->lobwritenam, rwm->lobwritevarn, rwm->loblengthnam, rwm->loblengthvarn, rwm->loboffset);
+			}
+			else
+			{
+				rwlcodeaddpupu(rwm, RWL_CODE_READLOB, rwm->lobnam, rwm->lobvarn, rwm->lobwritenam, rwm->lobwritevarn);
+			}
+	  	}
+	  
 	| RWL_T_WRITELOB { bis(rwm->m2flags, RWL_P2_MAYBECOMMAW); } RWL_T_IDENTIFIER maybecomma
           {
             sb4 l;
@@ -3149,6 +3106,81 @@ maybecomma:
 	| ',' { bic(rwm->m2flags, RWL_P2_MAYBECOMMAW); }
 	;
 
+readlobhead:
+	RWL_T_IDENTIFIER ','
+	{
+		sb4 l;
+		rwm->lobvarn = RWL_VAR_NOTFOUND;
+		rwm->lobnam = (yychar == RWL_T_IDENTIFIER)
+			? rwm->previnam
+			: rwm->inam;
+		l = rwlfindvar2(rwm->mxq, rwm->lobnam, RWL_VAR_NOGUESS, rwm->codename);
+		if (l>=0)
+		{
+			switch (rwm->mxq->evar[l].vtype)
+			{
+			case RWL_TYPE_BLOB:
+			case RWL_TYPE_CLOB:
+				rwm->lobvarn = l;
+			break;
+
+			default:
+				rwlerror(rwm,RWL_ERROR_INCORRECT_TYPE2, rwm->mxq->evar[l].stype, rwm->lobnam, "lob");
+			break;
+			}
+		}
+	}
+	RWL_T_IDENTIFIER
+	{
+		sb4 l;
+		rwm->lobwritevarn = 0;
+		rwm->loblengthvarn = 0;
+		rwm->loboffset = 0;
+		rwm->lobwritenam = (yychar == RWL_T_IDENTIFIER)
+			? rwm->previnam
+			: rwm->inam;
+		l = rwlfindvar2(rwm->mxq, rwm->lobwritenam, RWL_VAR_NOGUESS, rwm->codename);
+		if (l>=0)
+		{
+			switch (rwm->mxq->evar[l].vtype)
+			{
+				case RWL_TYPE_STR:
+					rwm->lobwritevarn = l;
+				break;
+				default:
+					rwlerror(rwm,RWL_ERROR_INCORRECT_TYPE2, rwm->mxq->evar[l].stype, rwm->lobwritenam, "string");
+				break;
+			}
+		}
+	}
+maybereadlobtail:
+	/*empty*/
+	| ',' RWL_T_IDENTIFIER 
+	{
+		sb4 l;
+		rwm->loblengthvarn = 0;
+		rwm->loblengthnam = (yychar == RWL_T_IDENTIFIER)
+			? rwm->previnam
+			: rwm->inam;
+		l = rwlfindvar2(rwm->mxq, rwm->loblengthnam, RWL_VAR_NOGUESS, rwm->codename);
+		if (l >= 0)
+		{
+			switch (rwm->mxq->evar[l].vtype)
+			{
+				case RWL_TYPE_INT:
+					rwm->loblengthvarn = l;
+				break;
+				default:
+					rwlerror(rwm,RWL_ERROR_INCORRECT_TYPE2, rwm->mxq->evar[l].stype, rwm->loblengthnam, "int");
+				break;
+			}
+		}
+	}
+	',' expression
+	{
+		rwm->loboffset = rwlexprfinish(rwm);
+	}
+
 docallonesql: 
 	  {
 	    /* simple sql execute */

src/rwlsql.c

@@ -11,6 +11,7 @@
  *
  * History
  *
+ * johnkenn 18-dec-2023 - Stream with length and offset from lob locator
  * bengsig   4-oct-2023 - Only set cclass on sessionpool if explict
  * bengsig   4-oct-2023 - Don't drop session after banner print with session pool
  * bengsig  27-sep-2023 - 24496 is possible with session pool timeout
@@ -4276,6 +4277,57 @@ void rwlreadlob(rwl_xeqenv *xev
   pnum->isnull = 0;
 }
 
+void rwlreadloblo(rwl_xeqenv *xev
+, OCILobLocator *lobp
+, rwl_cinfo *db
+, rwl_value *pnum
+, rwl_value *pnum2
+, ub8 offset
+, rwl_location *loc
+, text *fname
+)
+{
+  ub8 amtp = pnum->slen;
+	ub8 b_ampt = (ub8) pnum2->ival;
+
+	
+  if (!db)
+  {
+    rwlexecsevere(xev, loc, "[rwlreadlob-nodb]");
+    return;
+  }
+  rwlinitstrvar(xev, pnum);
+  if (OCI_SUCCESS != (xev->status= 
+    OCILobRead2(db->svchp
+			, xev->errhp
+			, lobp
+    	, &b_ampt /*byte_ampt*/
+			, 0 /*char_amtp*/
+			, (ub8)offset /*offset*/
+			, pnum->sval, amtp
+			, OCI_ONE_PIECE
+			, 0,0
+			, (ub2) 0, (ub1) SQLCS_IMPLICIT)))
+  {
+    rwldberror1(xev, loc, fname);
+    pnum->sval[0] = 0;
+    pnum->ival=0;
+    pnum->dval=0.0;
+		pnum2->sval[0] = 0;
+    pnum2->ival=0;
+    pnum2->dval=0.0;
+  }
+  else
+  {
+    pnum->sval[pnum2->ival] = 0;
+    pnum->ival=rwlatosb8(pnum->sval);
+    pnum->dval=rwlatof(pnum->sval);
+  }
+  pnum->isnull = 0;
+	pnum2->isnull = 0;
+}
+
+
 /* This routine will do the checking of an rwl_cinfo
  * that has been allocated and put into rwm->dbsav
  *