Consolidate Issue #161 fix behind two single-purpose helpers

The previous fix inlined the SQL_VARYING prefix write
(`*(unsigned short*)buf = len;` + data at `buf + 2`) into 18
`conv<Numeric|Date|Time>ToString[W]` helpers and repeated the
SQL_C_WCHAR → byte-variant reroute at 8 switch sites in
`getAdressFunction`, with a peek-only `HeadSqlVar::isSqlVarying()`
getter to let the ODBC layer inspect the prepared sqltype.

That shape is hard to maintain (any future `convDecfloatToString`
has to remember to copy the same branch) and leaks Firebird
buffer-layout knowledge into the ODBC conversion layer.

This commit collapses the repetition behind two named primitives:

* `HeadSqlVar::writeStringData(src, len)` — new inline method on
  the IscDbc interface, beside `setSqlLen`/`setSqlData`.  It writes
  into the sqlvar's pre-allocated buffer using the correct layout
  for the prepared type (`[uint16 len][data]` for SQL_VARYING,
  bare bytes + effective sqllen for SQL_TEXT) and does not mutate
  the VARYING metadata.  Replaces the `isSqlVarying()` getter —
  behavior, not a peek.

* `writeConvertedString(pointer, indicatorTo, to, src, len)` — new
  file-scope helper in OdbcConvert.cpp.  Single write-back path for
  every numeric/date/time → string converter: Firebird-side targets
  go through `writeStringData`, app-owned targets get a bare memcpy
  + indicator update.  Each `conv*ToString` helper now produces a
  local ASCII buffer and calls this helper instead of touching
  `*(unsigned short*)pointer` or `setSqlLen` directly.

* `chooseNumericToStringConv(to, byteFn, wideFn)` — tiny inline that
  replaces the 8 identical `if (to->isIndicatorSqlDa) return byte;
  else return wide;` blocks in `getAdressFunction`.  The rationale
  comment lives once, at the helper.

Also rewrites the `Sqlda::getPrecision` comment to explain that the
`orgVarSqlProperties` read for INPUT parameters is a symmetry with
the existing `getColumnDisplaySize` pattern (INPUT precision is
immutable from prepare time), not an Issue-161-specific workaround.
Code behavior unchanged.

Net: 18 + 8 scattered sites replaced by 2 helpers and 1 method;
ODBC layer no longer writes uint16 length prefixes or reads
`sqltype == SQL_VARYING`.

Verified against Firebird 5.0.3 on Windows x64, across all three
charset configs (UTF8+UTF8, ISO8859_1+ISO8859_1, ISO8859_1+UTF8):
125 passing tests / 0 failing, including
`Issue161_SLongToVarcharViaStoredProcedure`,
`Issue161_SLongToVarcharViaDml`, `NumericAsCharParam` and the rest
of `ParamConversionsTest` / `WCharTest`.

Author: fdcastel

IscDbc/Connection.h

@@ -524,11 +524,11 @@ class HeadSqlVar
 	//virtual void		setSqlSubType ( short subtype ) = 0;
 	virtual void		setSqlLen ( short len ) = 0;
 	virtual short		getSqlMultiple () = 0;
-	virtual bool		isSqlVarying () = 0;
 
 	virtual char *		getSqlData() = 0;
 	virtual short *		getSqlInd() = 0;
 	virtual void		setSqlData( char *data ) = 0;
+	virtual void		writeStringData( const char *src, int len ) = 0;
 	//virtual void		setSqlInd( short *ind ) = 0;
 
 	virtual bool		isReplaceForParamArray () = 0;

IscDbc/IscHeadSqlVar.h

@@ -102,7 +102,27 @@ class IscHeadSqlVar : public HeadSqlVar
 	inline short	getSqlMultiple () { return sqlMultiple; }
 	inline char *	getSqlData() { return sqlvar->sqldata; }
 	inline short *	getSqlInd() { return sqlvar->sqlind; }
-	inline bool		isSqlVarying() { return sqlvar->sqltype == SQL_VARYING; }
+
+	// Issue #161: write `len` bytes from `src` into the sqlvar's pre-allocated
+	// buffer, honoring Firebird's in-buffer layout for the prepared type:
+	//   SQL_VARYING : [uint16 len][data...] — leaves sqltype/sqllen untouched
+	//                 so checkAndRebuild() sees no override and Firebird reads
+	//                 the buffer using the original VARCHAR(N) metadata.
+	//   SQL_TEXT    : bare bytes; reports the effective length via sqllen.
+	inline void		writeStringData(const char *src, int len)
+	{
+		char *buf = sqlvar->sqldata;
+		if (sqlvar->sqltype == SQL_VARYING)
+		{
+			*(unsigned short*)buf = (unsigned short)len;
+			memcpy(buf + sizeof(short), src, len);
+		}
+		else
+		{
+			memcpy(buf, src, len);
+			sqlvar->sqllen = (short)len;
+		}
+	}
 
 	// not used
 	//void		setSqlInd( short *ind ) { sqlvar->sqlind = ind; }

IscDbc/Sqlda.cpp

@@ -760,15 +760,13 @@ const char* Sqlda::getColumnName(int index)
 int Sqlda::getPrecision(int index)
 {
 	CAttrSqlVar *curVar = Var(index);
-	// Issue #161: for INPUT parameters the conversion code mutates sqlvar
-	// (via setTypeText/setSqlLen).  Reading precision from the current
-	// sqlvar makes `record->length` shrink after the first row was bound,
-	// which then causes subsequent numeric→VARCHAR conversions to write
-	// only the first character of multi-digit values (silent data loss).
-	// The precision of a prepared parameter is immutable, so read the
-	// length/type snapshot captured at prepare time for INPUT params.
-	// SQL_ARRAY still needs the mutable CAttrSqlVar (for the `array`
-	// pointer), so fall through to Var(index) in that case.
+	// INPUT parameter precision is immutable from prepare time, even if the
+	// conversion layer later mutates sqllen on the CAttrSqlVar (e.g. the
+	// SQL_TEXT branch of writeStringData reports the effective length that
+	// way).  Read from the orgSqlProperties snapshot so re-binding never
+	// sees a shrunken precision — this mirrors getColumnDisplaySize above.
+	// OUTPUT always uses the current sqlvar; SQL_ARRAY needs the mutable
+	// CAttrSqlVar for its `array` pointer.
 	const SqlProperties *var =
 		(SqldaDir == SQLDA_INPUT && curVar->sqltype != SQL_ARRAY)
 			? orgVarSqlProperties(index)