refine errors even more

sivukhin · sivukhin · commit 9981d607a7df · 2024-07-26T18:54:58.000+04:00
diff --git a/libsql-sqlite3/src/vector.c b/libsql-sqlite3/src/vector.c
@@ -180,7 +180,7 @@ static int vectorParseSqliteText(
     pzText++;
 
   if( *pzText != '[' ){
-    *pzErrMsg = sqlite3_mprintf("invalid vector: must start with '['");
+    *pzErrMsg = sqlite3_mprintf("vector: must start with '['");
     goto error;
   }
   pzText++;
@@ -195,7 +195,7 @@ static int vectorParseSqliteText(
     }
     if( this != ',' && this != ']' ){
       if( iBuf > MAX_FLOAT_CHAR_SZ ){
-        *pzErrMsg = sqlite3_mprintf("invalid vector: float string length exceeded %d characters: '%s'", MAX_FLOAT_CHAR_SZ, valueBuf);
+        *pzErrMsg = sqlite3_mprintf("vector: float string length exceeded %d characters: '%s'", MAX_FLOAT_CHAR_SZ, valueBuf);
         goto error;
       }
       valueBuf[iBuf++] = this;
@@ -206,11 +206,11 @@ static int vectorParseSqliteText(
       break;
     }
     if( sqlite3AtoF(valueBuf, &elem, iBuf, SQLITE_UTF8) <= 0 ){
-      *pzErrMsg = sqlite3_mprintf("invalid vector: invalid float at position %d: '%s'", iElem, valueBuf);
+      *pzErrMsg = sqlite3_mprintf("vector: invalid float at position %d: '%s'", iElem, valueBuf);
       goto error;
     }
     if( iElem >= MAX_VECTOR_SZ ){
-      *pzErrMsg = sqlite3_mprintf("invalid vector: max size exceeded %d", MAX_VECTOR_SZ);
+      *pzErrMsg = sqlite3_mprintf("vector: max size exceeded %d", MAX_VECTOR_SZ);
       goto error;
     }
     // clear only first bufidx positions - all other are zero
@@ -229,7 +229,7 @@ static int vectorParseSqliteText(
     pzText++;
 
   if( *pzText != ']' ){
-    *pzErrMsg = sqlite3_mprintf("invalid vector: must end with ']'");
+    *pzErrMsg = sqlite3_mprintf("vector: must end with ']'");
     goto error;
   }
   pzText++;
@@ -238,7 +238,7 @@ static int vectorParseSqliteText(
     pzText++;
   
   if( *pzText != '\0' ){
-    *pzErrMsg = sqlite3_mprintf("invalid vector: non-space symbols after closing ']' are forbidden");
+    *pzErrMsg = sqlite3_mprintf("vector: non-space symbols after closing ']' are forbidden");
     goto error;
   }
   pVector->dims = iElem;
@@ -283,11 +283,11 @@ int detectBlobVectorParameters(sqlite3_value *arg, int *pType, int *pDims, char
   } else if( *pType == VECTOR_TYPE_FLOAT64 ){
     *pDims = nBlobSize / sizeof(double);
   } else{
-    *pzErrMsg = sqlite3_mprintf("invalid vector: unexpected binary type: got %d, expected %d or %d", *pType, VECTOR_TYPE_FLOAT32, VECTOR_TYPE_FLOAT64);
+    *pzErrMsg = sqlite3_mprintf("vector: unexpected binary type: got %d, expected %d or %d", *pType, VECTOR_TYPE_FLOAT32, VECTOR_TYPE_FLOAT64);
     return -1;
   }
   if( *pDims > MAX_VECTOR_SZ ){
-    *pzErrMsg = sqlite3_mprintf("invalid vector: max size exceeded: %d > %d", *pDims, MAX_VECTOR_SZ);
+    *pzErrMsg = sqlite3_mprintf("vector: max size exceeded: %d > %d", *pDims, MAX_VECTOR_SZ);
     return -1;
   }
   return 0;
@@ -334,7 +334,7 @@ int detectVectorParameters(sqlite3_value *arg, int typeHint, int *pType, int *pD
     case SQLITE_TEXT:
       return detectTextVectorParameters(arg, typeHint, pType, pDims, pzErrMsg);
     default:
-      *pzErrMsg = sqlite3_mprintf("invalid vector: unexpected value type: got %s, expected TEXT or BLOB", sqlite3_type_repr(sqlite3_value_type(arg)));
+      *pzErrMsg = sqlite3_mprintf("vector: unexpected value type: got %s, expected TEXT or BLOB", sqlite3_type_repr(sqlite3_value_type(arg)));
       return -1;
   }
 }
@@ -350,7 +350,7 @@ int vectorParse(
     case SQLITE_TEXT:
       return vectorParseSqliteText(arg, pVector, pzErrMsg);
     default:
-      *pzErrMsg = sqlite3_mprintf("invalid vector: unexpected value type: got %s, expected TEXT or BLOB", sqlite3_type_repr(sqlite3_value_type(arg)));
+      *pzErrMsg = sqlite3_mprintf("vector: unexpected value type: got %s, expected TEXT or BLOB", sqlite3_type_repr(sqlite3_value_type(arg)));
       return -1;
   }
 }
diff --git a/libsql-sqlite3/src/vectorIndex.c b/libsql-sqlite3/src/vectorIndex.c
@@ -411,7 +411,7 @@ static int parseVectorIdxParam(const char *zParam, VectorIdxParams *pParams, con
   zValue = zParam + iDelimiter + 1;
   nValueLen = sqlite3Strlen30(zValue);
   for(i = 0; i < ArraySize(VECTOR_PARAM_NAMES); i++){
-    if( sqlite3_strnicmp(VECTOR_PARAM_NAMES[i].zName, zParam, iDelimiter) != 0 ){
+    if( iDelimiter != strlen(VECTOR_PARAM_NAMES[i].zName) || sqlite3_strnicmp(VECTOR_PARAM_NAMES[i].zName, zParam, iDelimiter) != 0 ){
       continue;
     }
     if( VECTOR_PARAM_NAMES[i].type == 1 ){
@@ -454,33 +454,33 @@ static int parseVectorIdxParam(const char *zParam, VectorIdxParams *pParams, con
       return -1;
     }
   }
-  *pErrMsg = "unexpected parameter key";
+  *pErrMsg = "invalid parameter";
   return -1;
 }
 
 int parseVectorIdxParams(Parse *pParse, VectorIdxParams *pParams, int type, int dims, struct ExprList_item *pArgList, int nArgs) {
   int i;
   const char *pErrMsg;
   if( vectorIdxParamsPutU64(pParams, VECTOR_FORMAT_PARAM_ID, VECTOR_FORMAT_DEFAULT) != 0 ){
-    sqlite3ErrorMsg(pParse, "unable to serialize vector index parameter: format");
+    sqlite3ErrorMsg(pParse, "vector index: unable to serialize vector index parameter: format");
     return SQLITE_ERROR;
   }
   if( vectorIdxParamsPutU64(pParams, VECTOR_TYPE_PARAM_ID, type) != 0 ){
-    sqlite3ErrorMsg(pParse, "unable to serialize vector index parameter: type");
+    sqlite3ErrorMsg(pParse, "vector index: unable to serialize vector index parameter: type");
     return SQLITE_ERROR;
   }
   if( vectorIdxParamsPutU64(pParams, VECTOR_DIM_PARAM_ID, dims) != 0 ){
-    sqlite3ErrorMsg(pParse, "unable to serialize vector index parameter: dim");
+    sqlite3ErrorMsg(pParse, "vector index: unable to serialize vector index parameter: dim");
     return SQLITE_ERROR;
   }
   for(i = 0; i < nArgs; i++){
     Expr *pArgExpr = pArgList[i].pExpr;
     if( pArgExpr->op != TK_STRING ){
-      sqlite3ErrorMsg(pParse, "all arguments after first must be strings");
+      sqlite3ErrorMsg(pParse, "vector index: all arguments after first must be strings");
       return SQLITE_ERROR;
     }
     if( parseVectorIdxParam(pArgExpr->u.zToken, pParams, &pErrMsg) != 0 ){
-      sqlite3ErrorMsg(pParse, "invalid vector index parameter '%s': %s", pArgExpr->u.zToken, pErrMsg);
+      sqlite3ErrorMsg(pParse, "vector index: invalid vector index parameter '%s': %s", pArgExpr->u.zToken, pErrMsg);
       return SQLITE_ERROR;
     }
   }
@@ -909,7 +909,6 @@ int vectorIndexCreate(Parse *pParse, const Index *pIdx, const char *zDbSName, co
   }
   rc = parseVectorIdxParams(pParse, &idxParams, type, dims, pListItem + 1, pArgsList->nExpr - 1);
   if( rc != SQLITE_OK ){
-    sqlite3ErrorMsg(pParse, "vector index: failed to parse binary parameters");
     return CREATE_FAIL;
   }
   if( vectorIdxKeyGet(pTable, &idxKey, &pzErrMsg) != 0 ){
diff --git a/libsql-sqlite3/test/libsql_vector.test b/libsql-sqlite3/test/libsql_vector.test
@@ -90,16 +90,16 @@ do_test vector-1-func-errors {
   lappend ret [error_messages {SELECT vector_distance_cos('[1,2,3]', '[1,2]')}]
   lappend ret [error_messages {SELECT vector_distance_cos(vector32('[1,2,3]'), vector64('[1,2,3]'))}]
 } [list {*}{
-  {invalid vector: unexpected value type: got FLOAT, expected TEXT or BLOB}
-  {invalid vector: unexpected value type: got INTEGER, expected TEXT or BLOB}
-  {invalid vector: unexpected value type: got NULL, expected TEXT or BLOB}
-  {invalid vector: must start with '['}
-  {invalid vector: must start with '['}
-  {invalid vector: non-space symbols after closing ']' are forbidden}
-  {invalid vector: invalid float at position 0: '[1'}
-  {invalid vector: invalid float at position 2: '1.1.1'}
-  {invalid vector: must end with ']'}
-  {invalid vector: unexpected binary type: got 0, expected 1 or 2}
+  {vector: unexpected value type: got FLOAT, expected TEXT or BLOB}
+  {vector: unexpected value type: got INTEGER, expected TEXT or BLOB}
+  {vector: unexpected value type: got NULL, expected TEXT or BLOB}
+  {vector: must start with '['}
+  {vector: must start with '['}
+  {vector: non-space symbols after closing ']' are forbidden}
+  {vector: invalid float at position 0: '[1'}
+  {vector: invalid float at position 2: '1.1.1'}
+  {vector: must end with ']'}
+  {vector: unexpected binary type: got 0, expected 1 or 2}
   {vector_distance_cos: vectors must have the same length: 3 != 2}
   {vector_distance_cos: vectors must have the same type: 1 != 2}
 }]
diff --git a/libsql-sqlite3/test/libsql_vector_index.test b/libsql-sqlite3/test/libsql_vector_index.test
@@ -278,6 +278,9 @@ do_test vector-errors {
   lappend ret [error_messages {CREATE INDEX t_err_idx ON t_err( libsql_vector_idx(b) )}]
   lappend ret [error_messages {CREATE INDEX t_err_idx ON t_err( libsql_vector_idx(c) )}]
   lappend ret [error_messages {CREATE INDEX t_err_idx ON t_err( libsql_vector_idx(d) )}]
+  lappend ret [error_messages {CREATE INDEX t_err_idx ON t_err( libsql_vector_idx(e, 'a=1') )}]
+  lappend ret [error_messages {CREATE INDEX t_err_idx ON t_err( libsql_vector_idx(e, 'metric=unknown') )}]
+  lappend ret [error_messages {CREATE INDEX t_err_idx ON t_err( libsql_vector_idx(e, 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine', 'metric=cosine') )}]
   lappend ret [error_messages {CREATE INDEX t_err_idx ON t_err2( libsql_vector_idx(v) )}]
   sqlite3_exec db { CREATE TABLE t_err3 ( e FLOAT32(4) ) }
   sqlite3_exec db { CREATE INDEX t_err3_idx ON t_err3 (libsql_vector_idx(e)) }
@@ -298,6 +301,9 @@ do_test vector-errors {
   {vector index: unexpected vector column type: BLOB}
   {vector index: non digit symbol in vector column parameter: FLOAT32(-1)}
   {vector index: vector column must have non-zero dimension for index: FLOAT32(0)}
+  {vector index: invalid vector index parameter 'a=1': invalid parameter}
+  {vector index: invalid vector index parameter 'metric=unknown': invalid parameter}
+  {vector index: invalid vector index parameter 'metric=cosine': unable to serialize vector index parameter}
   {vector index: unsupported for tables without ROWID and composite primary key}
   {vector index(insert): dimensions are different: 1 != 4}
   {vector index(insert): dimensions are different: 5 != 4}

Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ static int vectorParseSqliteText(`
`180`	`180`	`pzText++;`
`181`	`181`
`182`	`182`	`if( *pzText != '[' ){`
`183`		`- *pzErrMsg = sqlite3_mprintf("invalid vector: must start with '['");`
	`183`	`+ *pzErrMsg = sqlite3_mprintf("vector: must start with '['");`
`184`	`184`	`goto error;`
`185`	`185`	`}`
`186`	`186`	`pzText++;`
`@@ -195,7 +195,7 @@ static int vectorParseSqliteText(`
`195`	`195`	`}`
`196`	`196`	`if( this != ',' && this != ']' ){`
`197`	`197`	`if( iBuf > MAX_FLOAT_CHAR_SZ ){`
`198`		`- *pzErrMsg = sqlite3_mprintf("invalid vector: float string length exceeded %d characters: '%s'", MAX_FLOAT_CHAR_SZ, valueBuf);`
	`198`	`+ *pzErrMsg = sqlite3_mprintf("vector: float string length exceeded %d characters: '%s'", MAX_FLOAT_CHAR_SZ, valueBuf);`
`199`	`199`	`goto error;`
`200`	`200`	`}`
`201`	`201`	`valueBuf[iBuf++] = this;`
`@@ -206,11 +206,11 @@ static int vectorParseSqliteText(`
`206`	`206`	`break;`
`207`	`207`	`}`
`208`	`208`	`if( sqlite3AtoF(valueBuf, &elem, iBuf, SQLITE_UTF8) <= 0 ){`
`209`		`- *pzErrMsg = sqlite3_mprintf("invalid vector: invalid float at position %d: '%s'", iElem, valueBuf);`
	`209`	`+ *pzErrMsg = sqlite3_mprintf("vector: invalid float at position %d: '%s'", iElem, valueBuf);`
`210`	`210`	`goto error;`
`211`	`211`	`}`
`212`	`212`	`if( iElem >= MAX_VECTOR_SZ ){`
`213`		`- *pzErrMsg = sqlite3_mprintf("invalid vector: max size exceeded %d", MAX_VECTOR_SZ);`
	`213`	`+ *pzErrMsg = sqlite3_mprintf("vector: max size exceeded %d", MAX_VECTOR_SZ);`
`214`	`214`	`goto error;`
`215`	`215`	`}`
`216`	`216`	`// clear only first bufidx positions - all other are zero`
`@@ -229,7 +229,7 @@ static int vectorParseSqliteText(`
`229`	`229`	`pzText++;`
`230`	`230`
`231`	`231`	`if( *pzText != ']' ){`
`232`		`- *pzErrMsg = sqlite3_mprintf("invalid vector: must end with ']'");`
	`232`	`+ *pzErrMsg = sqlite3_mprintf("vector: must end with ']'");`
`233`	`233`	`goto error;`
`234`	`234`	`}`
`235`	`235`	`pzText++;`
`@@ -238,7 +238,7 @@ static int vectorParseSqliteText(`
`238`	`238`	`pzText++;`
`239`	`239`
`240`	`240`	`if( *pzText != '\0' ){`
`241`		`- *pzErrMsg = sqlite3_mprintf("invalid vector: non-space symbols after closing ']' are forbidden");`
	`241`	`+ *pzErrMsg = sqlite3_mprintf("vector: non-space symbols after closing ']' are forbidden");`
`242`	`242`	`goto error;`
`243`	`243`	`}`
`244`	`244`	`pVector->dims = iElem;`
`@@ -283,11 +283,11 @@ int detectBlobVectorParameters(sqlite3_value arg, int pType, int *pDims, char`
`283`	`283`	`} else if( *pType == VECTOR_TYPE_FLOAT64 ){`
`284`	`284`	`*pDims = nBlobSize / sizeof(double);`
`285`	`285`	`} else{`
`286`		`- pzErrMsg = sqlite3_mprintf("invalid vector: unexpected binary type: got %d, expected %d or %d", pType, VECTOR_TYPE_FLOAT32, VECTOR_TYPE_FLOAT64);`
	`286`	`+ pzErrMsg = sqlite3_mprintf("vector: unexpected binary type: got %d, expected %d or %d", pType, VECTOR_TYPE_FLOAT32, VECTOR_TYPE_FLOAT64);`
`287`	`287`	`return -1;`
`288`	`288`	`}`
`289`	`289`	`if( *pDims > MAX_VECTOR_SZ ){`
`290`		`- pzErrMsg = sqlite3_mprintf("invalid vector: max size exceeded: %d > %d", pDims, MAX_VECTOR_SZ);`
	`290`	`+ pzErrMsg = sqlite3_mprintf("vector: max size exceeded: %d > %d", pDims, MAX_VECTOR_SZ);`
`291`	`291`	`return -1;`
`292`	`292`	`}`
`293`	`293`	`return 0;`
`@@ -334,7 +334,7 @@ int detectVectorParameters(sqlite3_value arg, int typeHint, int pType, int *pD`
`334`	`334`	`case SQLITE_TEXT:`
`335`	`335`	`return detectTextVectorParameters(arg, typeHint, pType, pDims, pzErrMsg);`
`336`	`336`	`default:`
`337`		`- *pzErrMsg = sqlite3_mprintf("invalid vector: unexpected value type: got %s, expected TEXT or BLOB", sqlite3_type_repr(sqlite3_value_type(arg)));`
	`337`	`+ *pzErrMsg = sqlite3_mprintf("vector: unexpected value type: got %s, expected TEXT or BLOB", sqlite3_type_repr(sqlite3_value_type(arg)));`
`338`	`338`	`return -1;`
`339`	`339`	`}`
`340`	`340`	`}`
`@@ -350,7 +350,7 @@ int vectorParse(`
`350`	`350`	`case SQLITE_TEXT:`
`351`	`351`	`return vectorParseSqliteText(arg, pVector, pzErrMsg);`
`352`	`352`	`default:`
`353`		`- *pzErrMsg = sqlite3_mprintf("invalid vector: unexpected value type: got %s, expected TEXT or BLOB", sqlite3_type_repr(sqlite3_value_type(arg)));`
	`353`	`+ *pzErrMsg = sqlite3_mprintf("vector: unexpected value type: got %s, expected TEXT or BLOB", sqlite3_type_repr(sqlite3_value_type(arg)));`
`354`	`354`	`return -1;`
`355`	`355`	`}`
`356`	`356`	`}`
Original file line number	Diff line number	Diff line change
`@@ -411,7 +411,7 @@ static int parseVectorIdxParam(const char zParam, VectorIdxParams pParams, con`
`411`	`411`	`zValue = zParam + iDelimiter + 1;`
`412`	`412`	`nValueLen = sqlite3Strlen30(zValue);`
`413`	`413`	`for(i = 0; i < ArraySize(VECTOR_PARAM_NAMES); i++){`
`414`		`- if( sqlite3_strnicmp(VECTOR_PARAM_NAMES[i].zName, zParam, iDelimiter) != 0 ){`
	`414`	`+ if( iDelimiter != strlen(VECTOR_PARAM_NAMES[i].zName) \|\| sqlite3_strnicmp(VECTOR_PARAM_NAMES[i].zName, zParam, iDelimiter) != 0 ){`
`415`	`415`	`continue;`
`416`	`416`	`}`
`417`	`417`	`if( VECTOR_PARAM_NAMES[i].type == 1 ){`
`@@ -454,33 +454,33 @@ static int parseVectorIdxParam(const char zParam, VectorIdxParams pParams, con`
`454`	`454`	`return -1;`
`455`	`455`	`}`
`456`	`456`	`}`
`457`		`- *pErrMsg = "unexpected parameter key";`
	`457`	`+ *pErrMsg = "invalid parameter";`
`458`	`458`	`return -1;`
`459`	`459`	`}`
`460`	`460`
`461`	`461`	`int parseVectorIdxParams(Parse pParse, VectorIdxParams pParams, int type, int dims, struct ExprList_item *pArgList, int nArgs) {`
`462`	`462`	`int i;`
`463`	`463`	`const char *pErrMsg;`
`464`	`464`	`if( vectorIdxParamsPutU64(pParams, VECTOR_FORMAT_PARAM_ID, VECTOR_FORMAT_DEFAULT) != 0 ){`
`465`		`- sqlite3ErrorMsg(pParse, "unable to serialize vector index parameter: format");`
	`465`	`+ sqlite3ErrorMsg(pParse, "vector index: unable to serialize vector index parameter: format");`
`466`	`466`	`return SQLITE_ERROR;`
`467`	`467`	`}`
`468`	`468`	`if( vectorIdxParamsPutU64(pParams, VECTOR_TYPE_PARAM_ID, type) != 0 ){`
`469`		`- sqlite3ErrorMsg(pParse, "unable to serialize vector index parameter: type");`
	`469`	`+ sqlite3ErrorMsg(pParse, "vector index: unable to serialize vector index parameter: type");`
`470`	`470`	`return SQLITE_ERROR;`
`471`	`471`	`}`
`472`	`472`	`if( vectorIdxParamsPutU64(pParams, VECTOR_DIM_PARAM_ID, dims) != 0 ){`
`473`		`- sqlite3ErrorMsg(pParse, "unable to serialize vector index parameter: dim");`
	`473`	`+ sqlite3ErrorMsg(pParse, "vector index: unable to serialize vector index parameter: dim");`
`474`	`474`	`return SQLITE_ERROR;`
`475`	`475`	`}`
`476`	`476`	`for(i = 0; i < nArgs; i++){`
`477`	`477`	`Expr *pArgExpr = pArgList[i].pExpr;`
`478`	`478`	`if( pArgExpr->op != TK_STRING ){`
`479`		`- sqlite3ErrorMsg(pParse, "all arguments after first must be strings");`
	`479`	`+ sqlite3ErrorMsg(pParse, "vector index: all arguments after first must be strings");`
`480`	`480`	`return SQLITE_ERROR;`
`481`	`481`	`}`
`482`	`482`	`if( parseVectorIdxParam(pArgExpr->u.zToken, pParams, &pErrMsg) != 0 ){`
`483`		`- sqlite3ErrorMsg(pParse, "invalid vector index parameter '%s': %s", pArgExpr->u.zToken, pErrMsg);`
	`483`	`+ sqlite3ErrorMsg(pParse, "vector index: invalid vector index parameter '%s': %s", pArgExpr->u.zToken, pErrMsg);`
`484`	`484`	`return SQLITE_ERROR;`
`485`	`485`	`}`
`486`	`486`	`}`
`@@ -909,7 +909,6 @@ int vectorIndexCreate(Parse pParse, const Index pIdx, const char *zDbSName, co`
`909`	`909`	`}`
`910`	`910`	`rc = parseVectorIdxParams(pParse, &idxParams, type, dims, pListItem + 1, pArgsList->nExpr - 1);`
`911`	`911`	`if( rc != SQLITE_OK ){`
`912`		`- sqlite3ErrorMsg(pParse, "vector index: failed to parse binary parameters");`
`913`	`912`	`return CREATE_FAIL;`
`914`	`913`	`}`
`915`	`914`	`if( vectorIdxKeyGet(pTable, &idxKey, &pzErrMsg) != 0 ){`