Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Various bugfixes. 68 Test cases still fail. (CVS 1471) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
67a140cf78d99e38ccd94751c4f8ead1 |
User & Date: | danielk1977 2004-05-27 09:28:42.000 |
Context
2004-05-27
| ||
10:30 | A few more bugfixes. Test cases pass now. (CVS 1472) (check-in: c9e3015faf user: danielk1977 tags: trunk) | |
09:28 | Various bugfixes. 68 Test cases still fail. (CVS 1471) (check-in: 67a140cf78 user: danielk1977 tags: trunk) | |
03:12 | Fixes to the MEM changes. The library now links. (CVS 1470) (check-in: f33d15d95f user: drh tags: trunk) | |
Changes
Changes to src/expr.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** ** $Id: expr.c,v 1.130 2004/05/27 09:28:42 danielk1977 Exp $ */ #include "sqliteInt.h" #include <ctype.h> char const *sqlite3AffinityString(char affinity){ switch( affinity ){ case SQLITE_AFF_INTEGER: return "i"; |
︙ | ︙ | |||
419 420 421 422 423 424 425 426 427 428 429 430 431 432 | case TK_ID: case TK_COLUMN: case TK_DOT: case TK_FUNCTION: return 0; case TK_NULL: case TK_STRING: case TK_INTEGER: case TK_FLOAT: case TK_VARIABLE: return 1; default: { if( p->pLeft && !sqlite3ExprIsConstant(p->pLeft) ) return 0; if( p->pRight && !sqlite3ExprIsConstant(p->pRight) ) return 0; | > | 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 | case TK_ID: case TK_COLUMN: case TK_DOT: case TK_FUNCTION: return 0; case TK_NULL: case TK_STRING: case TK_BLOB: case TK_INTEGER: case TK_FLOAT: case TK_VARIABLE: return 1; default: { if( p->pLeft && !sqlite3ExprIsConstant(p->pLeft) ) return 0; if( p->pRight && !sqlite3ExprIsConstant(p->pRight) ) return 0; |
︙ | ︙ | |||
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 | ** both been called on the expression before it is passed to this routine. */ int sqlite3ExprType(Expr *p){ if( p==0 ) return SQLITE_AFF_NONE; while( p ) switch( p->op ){ case TK_CONCAT: case TK_STRING: return SQLITE_AFF_TEXT; case TK_AS: p = p->pLeft; break; case TK_VARIABLE: | > | 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 | ** both been called on the expression before it is passed to this routine. */ int sqlite3ExprType(Expr *p){ if( p==0 ) return SQLITE_AFF_NONE; while( p ) switch( p->op ){ case TK_CONCAT: case TK_STRING: case TK_BLOB: return SQLITE_AFF_TEXT; case TK_AS: p = p->pLeft; break; case TK_VARIABLE: |
︙ | ︙ | |||
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 | case TK_BITOR: op = OP_BitOr; break; case TK_BITNOT: op = OP_BitNot; break; case TK_LSHIFT: op = OP_ShiftLeft; break; case TK_RSHIFT: op = OP_ShiftRight; break; case TK_REM: op = OP_Remainder; break; case TK_FLOAT: op = OP_Real; break; case TK_STRING: op = OP_String; break; default: break; } switch( pExpr->op ){ case TK_COLUMN: { if( pParse->useAgg ){ sqlite3VdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); }else if( pExpr->iColumn>=0 ){ | > | 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 | case TK_BITOR: op = OP_BitOr; break; case TK_BITNOT: op = OP_BitNot; break; case TK_LSHIFT: op = OP_ShiftLeft; break; case TK_RSHIFT: op = OP_ShiftRight; break; case TK_REM: op = OP_Remainder; break; case TK_FLOAT: op = OP_Real; break; case TK_STRING: op = OP_String; break; case TK_BLOB: op = OP_HexBlob; break; default: break; } switch( pExpr->op ){ case TK_COLUMN: { if( pParse->useAgg ){ sqlite3VdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); }else if( pExpr->iColumn>=0 ){ |
︙ | ︙ | |||
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 | break; } case TK_FLOAT: case TK_STRING: { sqlite3VdbeOp3(v, op, 0, 0, pExpr->token.z, pExpr->token.n); sqlite3VdbeDequoteP3(v, -1); break; } case TK_NULL: { sqlite3VdbeAddOp(v, OP_String, 0, 0); break; } case TK_VARIABLE: { sqlite3VdbeAddOp(v, OP_Variable, pExpr->iTable, 0); | > > > > > | 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 | break; } case TK_FLOAT: case TK_STRING: { sqlite3VdbeOp3(v, op, 0, 0, pExpr->token.z, pExpr->token.n); sqlite3VdbeDequoteP3(v, -1); break; } case TK_BLOB: { sqlite3VdbeOp3(v, op, 0, 0, pExpr->token.z+1, pExpr->token.n-1); sqlite3VdbeDequoteP3(v, -1); break; } case TK_NULL: { sqlite3VdbeAddOp(v, OP_String, 0, 0); break; } case TK_VARIABLE: { sqlite3VdbeAddOp(v, OP_Variable, pExpr->iTable, 0); |
︙ | ︙ |
Changes to src/func.c.
︙ | ︙ | |||
12 13 14 15 16 17 18 | ** This file contains the C functions that implement various SQL ** functions of SQLite. ** ** There is only one exported symbol in this file - the function ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** | | | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | ** This file contains the C functions that implement various SQL ** functions of SQLite. ** ** There is only one exported symbol in this file - the function ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** ** $Id: func.c,v 1.60 2004/05/27 09:28:42 danielk1977 Exp $ */ #include <ctype.h> #include <math.h> #include <stdlib.h> #include <assert.h> #include "sqliteInt.h" #include "vdbeInt.h" |
︙ | ︙ | |||
36 37 38 39 40 41 42 43 44 | ){ int i; int mask; /* 0 for min() or 0xffffffff for max() */ int iBest; if( argc==0 ) return; mask = (int)sqlite3_user_data(context); iBest = 0; for(i=1; i<argc; i++){ | > | | 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | ){ int i; int mask; /* 0 for min() or 0xffffffff for max() */ int iBest; if( argc==0 ) return; mask = (int)sqlite3_user_data(context); assert( mask==-1 || mask==0 ); iBest = 0; for(i=1; i<argc; i++){ if( (sqlite3MemCompare(argv[iBest], argv[i], 0)^mask)>=0 ){ iBest = i; } } sqlite3_result_value(context, argv[iBest]); } /* |
︙ | ︙ | |||
186 187 188 189 190 191 192 | /* ** Implementation of the upper() and lower() SQL functions. */ static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ char *z; int i; if( argc<1 || SQLITE3_NULL==sqlite3_value_type(argv[0]) ) return; | | | | 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 | /* ** Implementation of the upper() and lower() SQL functions. */ static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ char *z; int i; if( argc<1 || SQLITE3_NULL==sqlite3_value_type(argv[0]) ) return; z = sqliteMalloc(sqlite3_value_bytes(argv[0])+1); if( z==0 ) return; strcpy(z, sqlite3_value_text(argv[0])); for(i=0; z[i]; i++){ if( islower(z[i]) ) z[i] = toupper(z[i]); } sqlite3_result_text(context, z, -1, 1); sqliteFree(z); } static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ char *z; int i; if( argc<1 || SQLITE3_NULL==sqlite3_value_type(argv[0]) ) return; z = sqliteMalloc(sqlite3_value_bytes(argv[0])+1); if( z==0 ) return; strcpy(z, sqlite3_value_text(argv[0])); for(i=0; z[i]; i++){ if( isupper(z[i]) ) z[i] = tolower(z[i]); } sqlite3_result_text(context, z, -1, 1); sqliteFree(z); |
︙ | ︙ | |||
686 687 688 689 690 691 692 | #if 0 { "stddev", 1, 0, stdDevStep, stdDevFinalize }, #endif }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ | | > > > > | > > > > | 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 | #if 0 { "stddev", 1, 0, stdDevStep, stdDevFinalize }, #endif }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ void *pArg = 0; switch( aFuncs[i].argType ){ case 1: pArg = db; break; case 2: pArg = (void *)(-1); break; } sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, 0, 0, pArg, aFuncs[i].xFunc, 0, 0); } for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){ void *pArg = 0; switch( aAggs[i].argType ){ case 1: pArg = db; break; case 2: pArg = (void *)(-1); break; } sqlite3_create_function(db, aAggs[i].zName, aAggs[i].nArg, 0, 0, pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize); } sqlite3RegisterDateTimeFunctions(db); } |
Changes to src/parse.y.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** This file contains SQLite's grammar for SQL. Process this file ** using the lemon parser generator to generate C code that runs ** the parser. Lemon will also generate a header file containing ** numeric codes for all of the tokens. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** This file contains SQLite's grammar for SQL. Process this file ** using the lemon parser generator to generate C code that runs ** the parser. Lemon will also generate a header file containing ** numeric codes for all of the tokens. ** ** @(#) $Id: parse.y,v 1.118 2004/05/27 09:28:43 danielk1977 Exp $ */ %token_prefix TK_ %token_type {Token} %default_type {Token} %extra_argument {Parse *pParse} %syntax_error { if( pParse->zErrMsg==0 ){ |
︙ | ︙ | |||
545 546 547 548 549 550 551 552 553 554 555 556 557 558 | Expr *temp3 = sqlite3Expr(TK_ID, 0, 0, &Z); Expr *temp4 = sqlite3Expr(TK_DOT, temp2, temp3, 0); A = sqlite3Expr(TK_DOT, temp1, temp4, 0); } expr(A) ::= INTEGER(X). {A = sqlite3Expr(TK_INTEGER, 0, 0, &X);} expr(A) ::= FLOAT(X). {A = sqlite3Expr(TK_FLOAT, 0, 0, &X);} expr(A) ::= STRING(X). {A = sqlite3Expr(TK_STRING, 0, 0, &X);} expr(A) ::= VARIABLE(X). { A = sqlite3Expr(TK_VARIABLE, 0, 0, &X); if( A ) A->iTable = ++pParse->nVar; } expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = sqlite3ExprFunction(Y, &X); sqlite3ExprSpan(A,&X,&E); | > | 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 | Expr *temp3 = sqlite3Expr(TK_ID, 0, 0, &Z); Expr *temp4 = sqlite3Expr(TK_DOT, temp2, temp3, 0); A = sqlite3Expr(TK_DOT, temp1, temp4, 0); } expr(A) ::= INTEGER(X). {A = sqlite3Expr(TK_INTEGER, 0, 0, &X);} expr(A) ::= FLOAT(X). {A = sqlite3Expr(TK_FLOAT, 0, 0, &X);} expr(A) ::= STRING(X). {A = sqlite3Expr(TK_STRING, 0, 0, &X);} expr(A) ::= BLOB(X). {A = sqlite3Expr(TK_BLOB, 0, 0, &X);} expr(A) ::= VARIABLE(X). { A = sqlite3Expr(TK_VARIABLE, 0, 0, &X); if( A ) A->iTable = ++pParse->nVar; } expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = sqlite3ExprFunction(Y, &X); sqlite3ExprSpan(A,&X,&E); |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the SQLite library ** presents to client programs. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the SQLite library ** presents to client programs. ** ** @(#) $Id: sqlite.h.in,v 1.84 2004/05/27 09:28:43 danielk1977 Exp $ */ #ifndef _SQLITE_H_ #define _SQLITE_H_ #include <stdarg.h> /* Needed for the definition of va_list */ /* ** Make sure we can call this stuff from C++. |
︙ | ︙ | |||
368 369 370 371 372 373 374 375 376 377 378 379 380 381 | ** This second example is an SQL syntax error. As a general rule you ** should always use %q instead of %s when inserting text into a string ** literal. */ char *sqlite3_mprintf(const char*,...); char *sqlite3_vmprintf(const char*, va_list); void sqlite3_free(char *z); /* ** Windows systems need functions to call to return the sqlite3_version ** and sqlite3_encoding strings. */ const char *sqlite3_libversion(void); const char *sqlite3_libencoding(void); | > > | 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 | ** This second example is an SQL syntax error. As a general rule you ** should always use %q instead of %s when inserting text into a string ** literal. */ char *sqlite3_mprintf(const char*,...); char *sqlite3_vmprintf(const char*, va_list); void sqlite3_free(char *z); void sqlite3_freemem(void *z); /* ** Windows systems need functions to call to return the sqlite3_version ** and sqlite3_encoding strings. */ const char *sqlite3_libversion(void); const char *sqlite3_libencoding(void); |
︙ | ︙ |
Changes to src/test1.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing the printf() interface to SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** | | > > > > > > > > > > > > > > > > > > > > > > > > > > | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing the printf() interface to SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** ** $Id: test1.c,v 1.62 2004/05/27 09:28:43 danielk1977 Exp $ */ #include "sqliteInt.h" #include "tcl.h" #include "os.h" #include <stdlib.h> #include <string.h> #if OS_WIN # define PTR_FMT "%x" #else # define PTR_FMT "%p" #endif int sqlite3_exec_printf( sqlite *db, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ sqlite_callback xCallback, /* Callback function */ void *pArg, /* 1st argument to callback function */ char **errmsg, /* Error msg written here */ ... /* Arguments to the format string. */ ); int sqlite3_exec_printf( sqlite *db, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ sqlite_callback xCallback, /* Callback function */ void *pArg, /* 1st argument to callback function */ char **errmsg, /* Error msg written here */ ... /* Arguments to the format string. */ ); int sqlite3_get_table_printf( sqlite *db, /* An open database */ const char *sqlFormat, /* printf-style format string for the SQL */ char ***resultp, /* Result written to a char *[] that this points to */ int *nrow, /* Number of result rows written here */ int *ncol, /* Number of result columns written here */ char **errmsg, /* Error msg written here */ ... /* Arguments to the format string */ ); static const char * errorName(int rc){ const char *zName = 0; switch( rc ){ case SQLITE_OK: zName = "SQLITE_OK"; break; case SQLITE_ERROR: zName = "SQLITE_ERROR"; break; case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break; |
︙ | ︙ | |||
261 262 263 264 265 266 267 | char zBuf[30]; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; | | | 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 | char zBuf[30]; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; sprintf(zBuf, "%lld", sqlite3_last_insert_rowid(db)); Tcl_AppendResult(interp, zBuf, 0); return SQLITE_OK; } /* ** Usage: sqlite3_close DB ** |
︙ | ︙ | |||
427 428 429 430 431 432 433 | if( (argc==0 || SQLITE3_NULL!=sqlite3_value_type(argv[0]) ) && p ){ p->n++; } } static void countFinalize(sqlite3_context *context){ CountCtx *p; p = sqlite3_aggregate_context(context, sizeof(*p)); | | | 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 | if( (argc==0 || SQLITE3_NULL!=sqlite3_value_type(argv[0]) ) && p ){ p->n++; } } static void countFinalize(sqlite3_context *context){ CountCtx *p; p = sqlite3_aggregate_context(context, sizeof(*p)); sqlite3_result_int(context, p ? p->n : 0); } /* ** Usage: sqlite_test_create_aggregate DB ** ** Call the sqlite3_create_function API on the given database in order ** to create a function named "x_count". This function does the same thing |
︙ | ︙ | |||
652 653 654 655 656 657 658 | "may not be NULL", -1); }else if( sqlite3StrICmp(zArg0,"string")==0 ){ sqlite3_result_text(context, zArg1, -1, 1); }else if( zArg1==0 ){ sqlite3_result_error(context, "2nd argument may not be NULL if the " "first argument is not \"string\"", -1); }else if( sqlite3StrICmp(zArg0,"int")==0 ){ | | | 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 | "may not be NULL", -1); }else if( sqlite3StrICmp(zArg0,"string")==0 ){ sqlite3_result_text(context, zArg1, -1, 1); }else if( zArg1==0 ){ sqlite3_result_error(context, "2nd argument may not be NULL if the " "first argument is not \"string\"", -1); }else if( sqlite3StrICmp(zArg0,"int")==0 ){ sqlite3_result_int(context, atoi(zArg1)); }else if( sqlite3StrICmp(zArg0,"double")==0 ){ sqlite3_result_double(context, sqlite3AtoF(zArg1, 0)); }else{ sqlite3_result_error(context,"first argument should be one of: " "string int double", -1); } argc -= 2; |
︙ | ︙ | |||
851 852 853 854 855 856 857 | return TCL_ERROR; } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[3], &value) ) return TCL_ERROR; | | | 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 | return TCL_ERROR; } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[3], &value) ) return TCL_ERROR; rc = sqlite3_bind_int(pStmt, idx, value); if( rc!=SQLITE_OK ){ return TCL_ERROR; } return TCL_OK; } |
︙ | ︙ | |||
1427 1428 1429 1430 1431 1432 1433 | int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; int col; int len; | | | 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 | int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; int col; int len; const void *pBlob; if( objc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", Tcl_GetString(objv[0]), " STMT column", 0); return TCL_ERROR; } |
︙ | ︙ | |||
1469 1470 1471 1472 1473 1474 1475 | return TCL_ERROR; } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; rVal = sqlite3_column_double(pStmt, col); | | | 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 | return TCL_ERROR; } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR; rVal = sqlite3_column_double(pStmt, col); Tcl_SetObjResult(interp, Tcl_NewDoubleObj(rVal)); return TCL_OK; } /* ** Usage: sqlite3_data_count STMT ** ** Return the number of columns returned by the sql statement STMT. |
︙ | ︙ | |||
1554 1555 1556 1557 1558 1559 1560 | void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; int col; | | | 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 | void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; int col; const char *(*xFunc)(sqlite3_stmt*, int) = clientData; if( objc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", Tcl_GetString(objv[0]), " STMT column", 0); return TCL_ERROR; } |
︙ | ︙ | |||
1585 1586 1587 1588 1589 1590 1591 | int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; int col; Tcl_Obj *pRet; const void *zName16; | | | 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 | int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; int col; Tcl_Obj *pRet; const void *zName16; const void *(*xFunc)(sqlite3_stmt*, int) = clientData; if( objc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", Tcl_GetString(objv[0]), " STMT column", 0); return TCL_ERROR; } |
︙ | ︙ | |||
1619 1620 1621 1622 1623 1624 1625 | void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; int col; | | | 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 | void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; int col; int (*xFunc)(sqlite3_stmt*, int) = clientData; if( objc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", Tcl_GetString(objv[0]), " STMT column", 0); return TCL_ERROR; } |
︙ | ︙ | |||
1717 1718 1719 1720 1721 1722 1723 | }; int i; for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); } for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ | | > | 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 | }; int i; for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); } for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, aObjCmd[i].clientData, 0); } Tcl_LinkVar(interp, "sqlite_search_count", (char*)&sqlite3_search_count, TCL_LINK_INT); Tcl_LinkVar(interp, "sqlite_interrupt_count", (char*)&sqlite3_interrupt_count, TCL_LINK_INT); Tcl_LinkVar(interp, "sqlite_open_file_count", (char*)&sqlite3_open_file_count, TCL_LINK_INT); Tcl_LinkVar(interp, "sqlite_current_time", (char*)&sqlite3_current_time, TCL_LINK_INT); Tcl_LinkVar(interp, "sqlite_static_bind_value", (char*)&sqlite_static_bind_value, TCL_LINK_STRING); return TCL_OK; } |
Changes to src/tokenize.c.
︙ | ︙ | |||
11 12 13 14 15 16 17 | ************************************************************************* ** An tokenizer for SQL ** ** This file contains C code that splits an SQL input string up into ** individual tokens and sends those tokens one-by-one over to the ** parser for analysis. ** | | | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ************************************************************************* ** An tokenizer for SQL ** ** This file contains C code that splits an SQL input string up into ** individual tokens and sends those tokens one-by-one over to the ** parser for analysis. ** ** $Id: tokenize.c,v 1.71 2004/05/27 09:28:43 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include <stdlib.h> /* |
︙ | ︙ | |||
371 372 373 374 375 376 377 378 379 380 381 382 383 384 | *tokenType = TK_ID; return i; } case '?': { *tokenType = TK_VARIABLE; return 1; } default: { if( (*z&0x80)==0 && !isIdChar[*z] ){ break; } for(i=1; (z[i]&0x80)!=0 || isIdChar[z[i]]; i++){} *tokenType = sqlite3KeywordCode((char*)z, i); return i; | > > > > > > > > > > > > > > | 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 | *tokenType = TK_ID; return i; } case '?': { *tokenType = TK_VARIABLE; return 1; } case 'x': case 'X': { if( z[1]=='\'' || z[1]=='"' ){ int delim = z[0]; for(i=1; z[i]; i++){ if( z[i]==delim ){ break; } } if( z[i] ) i++; *tokenType = TK_BLOB; return i; } /* Otherwise fall through to the next case */ } default: { if( (*z&0x80)==0 && !isIdChar[*z] ){ break; } for(i=1; (z[i]&0x80)!=0 || isIdChar[z[i]]; i++){} *tokenType = sqlite3KeywordCode((char*)z, i); return i; |
︙ | ︙ |
Changes to src/utf.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used to translate between UTF-8, ** UTF-16, UTF-16BE, and UTF-16LE. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains routines used to translate between UTF-8, ** UTF-16, UTF-16BE, and UTF-16LE. ** ** $Id: utf.c,v 1.12 2004/05/27 09:28:43 danielk1977 Exp $ ** ** Notes on UTF-8: ** ** Byte-0 Byte-1 Byte-2 Byte-3 Value ** 0xxxxxxx 00000000 00000000 0xxxxxxx ** 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx ** 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx |
︙ | ︙ | |||
594 595 596 597 598 599 600 | if( enc1==TEXT_Utf8 ){ if( enc2==TEXT_Utf16le ){ *zOut = sqlite3utf8to16le(zData, nData); }else{ *zOut = sqlite3utf8to16be(zData, nData); } if( !(*zOut) ) return SQLITE_NOMEM; | | | | 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 | if( enc1==TEXT_Utf8 ){ if( enc2==TEXT_Utf16le ){ *zOut = sqlite3utf8to16le(zData, nData); }else{ *zOut = sqlite3utf8to16be(zData, nData); } if( !(*zOut) ) return SQLITE_NOMEM; *nOut = sqlite3utf16ByteLen(*zOut, -1); }else{ *zOut = sqlite3utf16to8(zData, nData, enc1==TEXT_Utf16be); if( !(*zOut) ) return SQLITE_NOMEM; *nOut = strlen(*zOut); } return SQLITE_OK; } |
Changes to src/util.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Utility functions used throughout sqlite. ** ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Utility functions used throughout sqlite. ** ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** ** $Id: util.c,v 1.91 2004/05/27 09:28:43 danielk1977 Exp $ */ #include "sqliteInt.h" #include <stdarg.h> #include <ctype.h> /* ** If malloc() ever fails, this global variable gets set to 1. |
︙ | ︙ | |||
1294 1295 1296 1297 1298 1299 1300 | int i = 0; do{ i++; v >>= 7; }while( v!=0 && i<9 ); return i; } | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 | int i = 0; do{ i++; v >>= 7; }while( v!=0 && i<9 ); return i; } char * sqlite3HexToBlob(const char *z){ char *zBlob; int i; int n = strlen(z); if( n%2 ) return 0; zBlob = (char *)sqliteMalloc(n/2); for(i=0; i<n; i+=2){ u8 c; if ( z[i]>47 && z[i]<58 ) c = (z[i]-48)<<4; else if( z[i]>64 && z[i]<71 ) c = (z[i]-55)<<4; else if( z[i]>96 && z[i]<103 ) c = (z[i]-87)<<4; else { sqliteFree(zBlob); return 0; } if ( z[i]>47 && z[i]<58 ) c += (z[i]-48); else if( z[i]>64 && z[i]<71 ) c += (z[i]-55); else if( z[i]>96 && z[i]<103 ) c += (z[i]-87); else { sqliteFree(zBlob); return 0; } zBlob[i/2] = c; } } |
Changes to src/vdbe.c.
︙ | ︙ | |||
39 40 41 42 43 44 45 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** | | | 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** ** $Id: vdbe.c,v 1.339 2004/05/27 09:28:43 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include "vdbeInt.h" /* |
︙ | ︙ | |||
123 124 125 126 127 128 129 130 131 132 133 134 135 136 | ** ** Any prior string or integer representation is retained. ** NULLs are converted into 0.0. */ #define Realify(P,enc) \ if(((P)->flags&MEM_Real)==0){ sqlite3VdbeMemRealify(P); } /* ** Insert a new aggregate element and make it the element that ** has focus. ** ** Return 0 on success and 1 if memory is exhausted. */ | > > > > > > > > > > > > > > > > > > > > > > > > | 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 | ** ** Any prior string or integer representation is retained. ** NULLs are converted into 0.0. */ #define Realify(P,enc) \ if(((P)->flags&MEM_Real)==0){ sqlite3VdbeMemRealify(P); } /* ** Argument pMem points at a memory cell that will be passed to a ** user-defined function or returned to the user as the result of a query. ** The second argument, 'db_enc' is the text encoding used by the vdbe for ** stack variables. This routine sets the pMem->enc and pMem->type ** variables used by the sqlite3_value_*() routines. */ static void StoreTypeInfo(Mem *pMem, u8 db_enc){ int flags = pMem->flags; if( flags & MEM_Null ){ pMem->type = SQLITE3_NULL; } else if( flags & MEM_Int ){ pMem->type = SQLITE3_INTEGER; } else if( flags & MEM_Real ){ pMem->type = SQLITE3_FLOAT; } else if( flags & MEM_Str ){ pMem->type = SQLITE3_TEXT; }else{ pMem->type = SQLITE3_BLOB; } } /* ** Insert a new aggregate element and make it the element that ** has focus. ** ** Return 0 on success and 1 if memory is exhausted. */ |
︙ | ︙ | |||
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 | case SQLITE_AFF_NUMERIC: if( 0==(pRec->flags&(MEM_Real|MEM_Int)) ){ /* pRec does not have a valid integer or real representation. ** Attempt a conversion if pRec has a string representation and ** it looks like a number. */ int realnum; if( pRec->flags&MEM_Str && sqlite3IsNumber(pRec->z, &realnum, enc) ){ if( realnum ){ Realify(pRec, enc); }else{ Integerify(pRec, enc); } } } if( affinity==SQLITE_AFF_INTEGER ){ /* For INTEGER affinity, try to convert a real value to an int */ | > | | 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 | case SQLITE_AFF_NUMERIC: if( 0==(pRec->flags&(MEM_Real|MEM_Int)) ){ /* pRec does not have a valid integer or real representation. ** Attempt a conversion if pRec has a string representation and ** it looks like a number. */ int realnum; sqlite3VdbeMemNulTerminate(pRec); if( pRec->flags&MEM_Str && sqlite3IsNumber(pRec->z, &realnum, enc) ){ if( realnum ){ Realify(pRec, enc); }else{ Integerify(pRec, enc); } } } if( affinity==SQLITE_AFF_INTEGER ){ /* For INTEGER affinity, try to convert a real value to an int */ if( (pRec->flags&MEM_Real) && !(pRec->flags&MEM_Int) ){ pRec->i = pRec->r; if( ((double)pRec->i)==pRec->r ){ pRec->flags |= MEM_Int; } } } break; |
︙ | ︙ | |||
758 759 760 761 762 763 764 | /* Opcode: String * * P3 ** ** The string value P3 is pushed onto the stack. If P3==0 then a ** NULL is pushed onto the stack. */ case OP_String: { pTos++; | > | | | | | > > > > > > > > > > > > > > > > > > > > > > > > | 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 | /* Opcode: String * * P3 ** ** The string value P3 is pushed onto the stack. If P3==0 then a ** NULL is pushed onto the stack. */ case OP_String: { pTos++; if( pOp->p3 ){ pTos->flags = MEM_Str|MEM_Static|MEM_Term; pTos->enc = TEXT_Utf8; pTos->z = pOp->p3; pTos->n = strlen(pTos->z); sqlite3VdbeChangeEncoding(pTos, db->enc); }else{ pTos->flags = MEM_Null; } break; } #if 0 /* Opcode: HexBlob * * P3 ** ** This opcode does not exist at vdbe execution time. */ case OP_HexBlob: { break; } #endif /* Opcode: Blob P1 * P3 ** ** P3 points to a blob of data P1 bytes long. Push this ** value onto the stack. */ case OP_Blob: { pTos++; sqlite3VdbeMemSetStr(pTos, pOp->p3, pOp->p1, 0, 0); break; } /* Opcode: Variable P1 * * ** ** Push the value of variable P1 onto the stack. A variable is ** an unknown in the original SQL string as handed to sqlite3_compile(). |
︙ | ︙ | |||
981 982 983 984 985 986 987 988 989 990 991 992 993 994 | case OP_Callback: { int i; assert( p->nResColumn==pOp->p1 ); for(i=0; i<pOp->p1; i++){ Mem *pVal = &pTos[0-i]; sqlite3VdbeMemNulTerminate(pVal); } p->resOnStack = 1; p->nCallback++; p->popStack = pOp->p1; p->pc = pc + 1; p->pTos = pTos; | > | 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 | case OP_Callback: { int i; assert( p->nResColumn==pOp->p1 ); for(i=0; i<pOp->p1; i++){ Mem *pVal = &pTos[0-i]; sqlite3VdbeMemNulTerminate(pVal); StoreTypeInfo(pVal, db->enc); } p->resOnStack = 1; p->nCallback++; p->popStack = pOp->p1; p->pc = pc + 1; p->pTos = pTos; |
︙ | ︙ | |||
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 | mSep.z = pOp->p3; mSep.n = strlen(mSep.z); mSep.flags = MEM_Str|MEM_Static|MEM_Term; mSep.enc = TEXT_Utf8; sqlite3VdbeChangeEncoding(&mSep, db->enc); }else{ mSep.flags = MEM_Null; } /* Loop through the stack elements to see how long the result will be. */ nField = pOp->p1; pTerm = &pTos[1-nField]; nByte = (nField-1)*mSep.n; for(i=0; i<nField; i++, pTerm++){ | > | 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 | mSep.z = pOp->p3; mSep.n = strlen(mSep.z); mSep.flags = MEM_Str|MEM_Static|MEM_Term; mSep.enc = TEXT_Utf8; sqlite3VdbeChangeEncoding(&mSep, db->enc); }else{ mSep.flags = MEM_Null; mSep.n = 0; } /* Loop through the stack elements to see how long the result will be. */ nField = pOp->p1; pTerm = &pTos[1-nField]; nByte = (nField-1)*mSep.n; for(i=0; i<nField; i++, pTerm++){ |
︙ | ︙ | |||
1069 1070 1071 1072 1073 1074 1075 | if( i<nField-1 && !(mSep.flags|MEM_Null) ){ memcpy(&zNew[j], mSep.z, mSep.n); j += mSep.n; } } zNew[j] = 0; zNew[j+1] = 0; | | | 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 | if( i<nField-1 && !(mSep.flags|MEM_Null) ){ memcpy(&zNew[j], mSep.z, mSep.n); j += mSep.n; } } zNew[j] = 0; zNew[j+1] = 0; assert( j==nByte ); if( pOp->p2==0 ){ popStack(&pTos, nField); } pTos++; pTos->n = j; pTos->flags = MEM_Str|MEM_Dyn|MEM_Term; |
︙ | ︙ | |||
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 | n = pOp->p1; apVal = p->apArg; assert( apVal || n==0 ); pArg = &pTos[1-n]; for(i=0; i<n; i++, pArg++){ apVal[i] = pArg; } ctx.pFunc = (FuncDef*)pOp->p3; ctx.s.flags = MEM_Null; ctx.s.z = 0; ctx.isError = 0; ctx.isStep = 0; | > | 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 | n = pOp->p1; apVal = p->apArg; assert( apVal || n==0 ); pArg = &pTos[1-n]; for(i=0; i<n; i++, pArg++){ apVal[i] = pArg; StoreTypeInfo(pArg, db->enc); } ctx.pFunc = (FuncDef*)pOp->p3; ctx.s.flags = MEM_Null; ctx.s.z = 0; ctx.isError = 0; ctx.isStep = 0; |
︙ | ︙ | |||
4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 | ** and put them on the sorter. The key and data should have been ** made using SortMakeKey and SortMakeRec, respectively. */ case OP_SortPut: { Mem *pNos = &pTos[-1]; Sorter *pSorter; assert( pNos>=p->aStack ); if( Dynamicify(pTos, db->enc) || Dynamicify(pNos, db->enc) ) goto no_mem; pSorter = sqliteMallocRaw( sizeof(Sorter) ); if( pSorter==0 ) goto no_mem; pSorter->pNext = p->pSort; p->pSort = pSorter; assert( pTos->flags & MEM_Dyn ); pSorter->nKey = pTos->n; | > | 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 | ** and put them on the sorter. The key and data should have been ** made using SortMakeKey and SortMakeRec, respectively. */ case OP_SortPut: { Mem *pNos = &pTos[-1]; Sorter *pSorter; assert( pNos>=p->aStack ); Stringify(pNos, db->enc); if( Dynamicify(pTos, db->enc) || Dynamicify(pNos, db->enc) ) goto no_mem; pSorter = sqliteMallocRaw( sizeof(Sorter) ); if( pSorter==0 ) goto no_mem; pSorter->pNext = p->pSort; p->pSort = pSorter; assert( pTos->flags & MEM_Dyn ); pSorter->nKey = pTos->n; |
︙ | ︙ | |||
4342 4343 4344 4345 4346 4347 4348 | /* Opcode: FileColumn P1 * * ** ** Push onto the stack the P1-th column of the most recently read line ** from the input file. */ case OP_FileColumn: { | > | > > | > > < | 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 | /* Opcode: FileColumn P1 * * ** ** Push onto the stack the P1-th column of the most recently read line ** from the input file. */ case OP_FileColumn: { /* ** FIX ME: This will be deleted, but loads of test case files have ** to be updated first... */ int i = pOp->p1; char *z; assert( i>=0 && i<p->nField ); if( p->azField ){ z = p->azField[i]; }else{ z = 0; } pTos++; if( z ){ pTos->n = strlen(z); pTos->z = z; pTos->flags = MEM_Str | MEM_Ephem | MEM_Term; pTos->enc = TEXT_Utf8; sqlite3VdbeChangeEncoding(pTos, db->enc); }else{ pTos->flags = MEM_Null; } break; } /* Opcode: MemStore P1 P2 * ** ** Write the top of the stack into memory location P1. ** P1 should be a small integer since space is allocated |
︙ | ︙ | |||
4516 4517 4518 4519 4520 4521 4522 | pRec = &pTos[-n]; assert( pRec>=p->aStack ); apVal = p->apArg; assert( apVal || n==0 ); for(i=0; i<n; i++, pRec++){ | | > | 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 | pRec = &pTos[-n]; assert( pRec>=p->aStack ); apVal = p->apArg; assert( apVal || n==0 ); for(i=0; i<n; i++, pRec++){ apVal[i] = pRec; StoreTypeInfo(pRec, db->enc); } i = pTos->i; assert( i>=0 && i<p->agg.nMem ); ctx.pFunc = (FuncDef*)pOp->p3; pMem = &p->agg.pCurrent->aMem[i]; ctx.s.z = pMem->zShort; /* Space used for small aggregate contexts */ ctx.pAgg = pMem->z; |
︙ | ︙ | |||
4724 4725 4726 4727 4728 4729 4730 | ** of the program. It is only here for testing and debugging. ** On the other hand, it does burn CPU cycles every time through ** the evaluator loop. So we can leave it out when NDEBUG is defined. */ #ifndef NDEBUG /* Sanity checking on the top element of the stack */ if( pTos>=p->aStack ){ | < < < < < < < < < < | < < < < < < < | 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 | ** of the program. It is only here for testing and debugging. ** On the other hand, it does burn CPU cycles every time through ** the evaluator loop. So we can leave it out when NDEBUG is defined. */ #ifndef NDEBUG /* Sanity checking on the top element of the stack */ if( pTos>=p->aStack ){ sqlite3VdbeMemSanity(pTos, db->enc); } if( pc<-1 || pc>=p->nOp ){ sqlite3SetString(&p->zErrMsg, "jump destination out of range", (char*)0); rc = SQLITE_INTERNAL; } if( p->trace && pTos>=p->aStack ){ int i; |
︙ | ︙ |
Changes to src/vdbeInt.h.
︙ | ︙ | |||
360 361 362 363 364 365 366 | void sqlite3VdbeMemSetDouble(Mem*, double); void sqlite3VdbeMemSetNull(Mem*); int sqlite3VdbeMemMakeWriteable(Mem*); int sqlite3VdbeMemDynamicify(Mem*); int sqlite3VdbeMemStringify(Mem*, int); int sqlite3VdbeMemIntegerify(Mem*); int sqlite3VdbeMemRealify(Mem*); | > > > > | 360 361 362 363 364 365 366 367 368 369 370 | void sqlite3VdbeMemSetDouble(Mem*, double); void sqlite3VdbeMemSetNull(Mem*); int sqlite3VdbeMemMakeWriteable(Mem*); int sqlite3VdbeMemDynamicify(Mem*); int sqlite3VdbeMemStringify(Mem*, int); int sqlite3VdbeMemIntegerify(Mem*); int sqlite3VdbeMemRealify(Mem*); #ifndef NDEBUG void sqlite3VdbeMemSanity(Mem*, u8); #endif |
Changes to src/vdbeapi.c.
︙ | ︙ | |||
91 92 93 94 95 96 97 | sqlite3VdbeMemStringify(pVal, TEXT_Utf16); } return (const void *)(pVal->z); } int sqlite3_value_type(sqlite3_value* pVal){ return pVal->type; | < < < < < < < < < < < < < < < < < < < | 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | sqlite3VdbeMemStringify(pVal, TEXT_Utf16); } return (const void *)(pVal->z); } int sqlite3_value_type(sqlite3_value* pVal){ return pVal->type; } /**************************** sqlite3_result_ ******************************* ** The following routines are used by user-defined functions to specify ** the function result. */ void sqlite3_result_blob( |
︙ | ︙ | |||
282 283 284 285 286 287 288 289 290 291 292 293 294 295 | return &pVm->pTos[(1-vals)+i]; } /**************************** sqlite3_column_ ******************************* ** The following routines are used to access elements of the current row ** in the result set. */ int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){ return sqlite3_value_bytes( columnMem(pStmt,i) ); } int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){ return sqlite3_value_bytes16( columnMem(pStmt,i) ); } double sqlite3_column_double(sqlite3_stmt *pStmt, int i){ | > > > | 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 | return &pVm->pTos[(1-vals)+i]; } /**************************** sqlite3_column_ ******************************* ** The following routines are used to access elements of the current row ** in the result set. */ const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){ return sqlite3_value_blob( columnMem(pStmt,i) ); } int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){ return sqlite3_value_bytes( columnMem(pStmt,i) ); } int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){ return sqlite3_value_bytes16( columnMem(pStmt,i) ); } double sqlite3_column_double(sqlite3_stmt *pStmt, int i){ |
︙ | ︙ |
Changes to src/vdbeaux.c.
︙ | ︙ | |||
601 602 603 604 605 606 607 608 609 610 611 612 613 614 | p->pTos = pMem; p->rc = SQLITE_OK; p->resOnStack = 1; rc = SQLITE_ROW; } return rc; } /* ** Prepare a virtual machine for execution. This involves things such ** as allocating stack space and initializing the program counter. ** After the VDBE has be prepped, it can be executed by one or more ** calls to sqlite3VdbeExec(). */ | > > > > > > > > > > > > > > > > > > > > > > | 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 | p->pTos = pMem; p->rc = SQLITE_OK; p->resOnStack = 1; rc = SQLITE_ROW; } return rc; } /* ** If pOp is an OP_HexBlob opcode, then transform it to an OP_Blob ** opcode. */ static int translateOp(Op *pOp){ if( pOp->opcode==OP_HexBlob ){ char *zBlob = sqlite3HexToBlob(pOp->p3); if( !zBlob ){ if( sqlite3_malloc_failed ){ return SQLITE_NOMEM; } return SQLITE_ERROR; } pOp->p1 = strlen(pOp->p3)/2; if( pOp->p3type==P3_DYNAMIC ){ sqliteFree(pOp->p3); } pOp->p3 = zBlob; pOp->p3type = P3_DYNAMIC; } } /* ** Prepare a virtual machine for execution. This involves things such ** as allocating stack space and initializing the program counter. ** After the VDBE has be prepped, it can be executed by one or more ** calls to sqlite3VdbeExec(). */ |
︙ | ︙ | |||
673 674 675 676 677 678 679 680 681 682 683 684 685 686 | int i; for(i=0; i<p->nOp; i++){ p->aOp[i].cnt = 0; p->aOp[i].cycles = 0; } } #endif } /* ** Remove any elements that remain on the sorter for the VDBE given. */ void sqlite3VdbeSorterReset(Vdbe *p){ | > > > > > > | 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 | int i; for(i=0; i<p->nOp; i++){ p->aOp[i].cnt = 0; p->aOp[i].cycles = 0; } } #endif { int i; for(i=0; i<p->nOp; i++){ translateOp(&p->aOp[i]); } } } /* ** Remove any elements that remain on the sorter for the VDBE given. */ void sqlite3VdbeSorterReset(Vdbe *p){ |
︙ | ︙ | |||
1266 1267 1268 1269 1270 1271 1272 1273 1274 | } return len; } /* String or blob */ assert( serial_type>=12 ); len = sqlite3VdbeSerialTypeLen(serial_type); if( serial_type&0x01 ){ pMem->flags = MEM_Str | MEM_Ephem; | > > | < | 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 | } return len; } /* String or blob */ assert( serial_type>=12 ); len = sqlite3VdbeSerialTypeLen(serial_type); pMem->z = buf; pMem->n = len; if( serial_type&0x01 ){ pMem->flags = MEM_Str | MEM_Ephem; pMem->enc = enc; }else{ pMem->flags = MEM_Blob | MEM_Ephem; } sqlite3VdbeMemMakeWriteable(pMem); return len; } /* ** The following is the comparison function for (non-integer) |
︙ | ︙ |
Changes to src/vdbemem.c.
︙ | ︙ | |||
78 79 80 81 82 83 84 | /* ** Make the given Mem object MEM_Dyn. ** ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails. */ int sqlite3VdbeMemDynamicify(Mem *pMem){ | | | 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 | /* ** Make the given Mem object MEM_Dyn. ** ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails. */ int sqlite3VdbeMemDynamicify(Mem *pMem){ int n = pMem->n; u8 *z; if( (pMem->flags & (MEM_Ephem|MEM_Static|MEM_Short))==0 ){ return SQLITE_OK; } assert( (pMem->flags & MEM_Dyn)==0 ); assert( pMem->flags & (MEM_Str|MEM_Blob) ); z = sqliteMallocRaw( n+2 ); |
︙ | ︙ | |||
195 196 197 198 199 200 201 | } /* ** Release any memory held by the Mem */ static void releaseMem(Mem *p){ if( p->flags & MEM_Dyn ){ | | > | 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 | } /* ** Release any memory held by the Mem */ static void releaseMem(Mem *p){ if( p->flags & MEM_Dyn ){ sqliteFree(p->z); p->z = 0; } } /* ** Convert the Mem to have representation MEM_Int only. All ** prior representations are invalidated. NULL is converted into 0. */ |
︙ | ︙ | |||
231 232 233 234 235 236 237 | /* ** Add MEM_Real to the set of representations for pMem. Prior ** prior representations other than MEM_Null retained. NULL is ** converted into 0.0. */ int sqlite3VdbeMemRealify(Mem *pMem){ if( pMem->flags & MEM_Int ){ | | | 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 | /* ** Add MEM_Real to the set of representations for pMem. Prior ** prior representations other than MEM_Null retained. NULL is ** converted into 0.0. */ int sqlite3VdbeMemRealify(Mem *pMem){ if( pMem->flags & MEM_Int ){ pMem->r = pMem->i; pMem->flags |= MEM_Real; }else if( pMem->flags & (MEM_Str|MEM_Blob) ){ if( sqlite3VdbeChangeEncoding(pMem, TEXT_Utf8) || sqlite3VdbeMemNulTerminate(pMem) ){ return SQLITE_NOMEM; } assert( pMem->z ); |
︙ | ︙ | |||
440 441 442 443 444 445 446 | */ rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n); if( rc==0 ){ rc = pMem1->n - pMem2->n; } return rc; } | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 | */ rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n); if( rc==0 ){ rc = pMem1->n - pMem2->n; } return rc; } #ifndef NDEBUG /* ** Perform various checks on the memory cell pMem. An assert() will ** fail if pMem is internally inconsistent. */ void sqlite3VdbeMemSanity(Mem *pMem, u8 db_enc){ int flags = pMem->flags; assert( flags!=0 ); /* Must define some type */ if( pMem->flags & (MEM_Str|MEM_Blob) ){ int x = pMem->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short); assert( x!=0 ); /* Strings must define a string subtype */ assert( (x & (x-1))==0 ); /* Only one string subtype can be defined */ assert( pMem->z!=0 ); /* Strings must have a value */ /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */ assert( (pMem->flags & MEM_Short)==0 || pMem->z==pMem->zShort ); assert( (pMem->flags & MEM_Short)!=0 || pMem->z!=pMem->zShort ); if( (flags & MEM_Str) ){ assert( pMem->enc==TEXT_Utf8 || pMem->enc==TEXT_Utf16le || pMem->enc==TEXT_Utf16be ); /* If the string is UTF-8 encoded and nul terminated, then pMem->n ** must be the length of the string. */ if( pMem->enc==TEXT_Utf8 && (flags & MEM_Term) ){ assert( strlen(pMem->z)==pMem->n ); } } }else{ /* Cannot define a string subtype for non-string objects */ assert( (pMem->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 ); } /* MEM_Null excludes all other types */ assert( (pMem->flags&(MEM_Str|MEM_Int|MEM_Real|MEM_Blob))==0 || (pMem->flags&MEM_Null)==0 ); } #endif |
Changes to test/bind.test.
1 2 3 4 5 6 7 8 9 10 11 12 13 | # 2003 September 6 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this script testing the sqlite_bind API. # | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | # 2003 September 6 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this script testing the sqlite_bind API. # # $Id: bind.test,v 1.11 2004/05/27 09:28:44 danielk1977 Exp $ # set testdir [file dirname $argv0] source $testdir/tester.tcl proc sqlite_step {stmt N VALS COLS} { upvar VALS vals |
︙ | ︙ | |||
170 171 172 173 174 175 176 | DELETE FROM t1; } } {} # UTF-8 text do_test bind-6.1 { sqlite3_bind_text $VM 1 hellothere 5 | | | 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 | DELETE FROM t1; } } {} # UTF-8 text do_test bind-6.1 { sqlite3_bind_text $VM 1 hellothere 5 sqlite3_bind_text $VM 2 ".." 1 sqlite3_bind_text $VM 3 world -1 sqlite_step $VM N VALUES COLNAMES sqlite3_reset $VM execsql {SELECT rowid, * FROM t1} } {1 hello . world} do_test bind-6.2 { execsql {SELECT typeof(a), typeof(b), typeof(c) FROM t1} |
︙ | ︙ |
Changes to test/capi3.test.
1 2 3 4 5 6 7 8 9 10 11 12 13 | # 2003 January 29 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this script testing the callback-free C/C++ API. # | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | # 2003 January 29 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this script testing the callback-free C/C++ API. # # $Id: capi3.test,v 1.8 2004/05/27 09:28:44 danielk1977 Exp $ # set testdir [file dirname $argv0] source $testdir/tester.tcl # Return the UTF-16 representation of the supplied UTF-8 string $str. # If $nt is true, append two 0x00 bytes as a nul terminator. |
︙ | ︙ | |||
148 149 150 151 152 153 154 | set db2 [sqlite3_open16 [utf16 /bogus/path/test.db] {}] } sqlite3_errcode $db2 } {SQLITE_CANTOPEN} do_test capi3-4.4 { utf8 [sqlite3_errmsg16 $db2] } {unable to open database file} | | | 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | set db2 [sqlite3_open16 [utf16 /bogus/path/test.db] {}] } sqlite3_errcode $db2 } {SQLITE_CANTOPEN} do_test capi3-4.4 { utf8 [sqlite3_errmsg16 $db2] } {unable to open database file} do_test capi3-4.5 { sqlite3_close $db2 } {} # This proc is used to test the following API calls: # # sqlite3_column_count # sqlite3_column_name |
︙ | ︙ | |||
170 171 172 173 174 175 176 | # $decltypes is a list of column declaration types for $STMT. # # Example: # # set STMT [sqlite3_prepare "SELECT 1, 2, 2;" -1 DUMMY] # check_header test1.1 {1 2 3} {"" "" ""} # | | | | | 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | # $decltypes is a list of column declaration types for $STMT. # # Example: # # set STMT [sqlite3_prepare "SELECT 1, 2, 2;" -1 DUMMY] # check_header test1.1 {1 2 3} {"" "" ""} # proc check_header {STMT test names decltypes} { # Use the return value of sqlite3_column_count() to build # a list of column indexes. i.e. If sqlite3_column_count # is 3, build the list {0 1 2}. set ::idxlist [list] set numcols [sqlite3_column_count $STMT] for {set i 0} {$i < $numcols} {incr i} {lappend ::idxlist $i} # Column names in UTF-8 do_test $test.1 { set cnamelist [list] foreach i $idxlist {lappend cnamelist [sqlite3_column_name $STMT $i]} set cnamelist } $names |
︙ | ︙ | |||
235 236 237 238 239 240 241 | # check_data test1.2 {TEXT REAL NULL} {0 1 0} {0 1.1 0} {hello 1.1 {}} # proc check_data {STMT test types ints doubles strings} { # Use the return value of sqlite3_column_count() to build # a list of column indexes. i.e. If sqlite3_column_count # is 3, build the list {0 1 2}. | | | | 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | # check_data test1.2 {TEXT REAL NULL} {0 1 0} {0 1.1 0} {hello 1.1 {}} # proc check_data {STMT test types ints doubles strings} { # Use the return value of sqlite3_column_count() to build # a list of column indexes. i.e. If sqlite3_column_count # is 3, build the list {0 1 2}. set ::idxlist [list] set numcols [sqlite3_data_count $STMT] for {set i 0} {$i < $numcols} {incr i} {lappend ::idxlist $i} # types do_test $test.1 { set types [list] foreach i $idxlist {lappend types [sqlite3_column_type $STMT $i]} set types } $types |
︙ | ︙ | |||
309 310 311 312 313 314 315 316 317 318 319 320 321 322 | } do_test capi3-5.0 { execsql { CREATE TABLE t1(a VARINT, b BLOB, c VARCHAR(16)); INSERT INTO t1 VALUES(1, 2, 3); INSERT INTO t1 VALUES('one', 'two', NULL); } set sql "SELECT * FROM t1" set STMT [sqlite3_prepare $DB $sql -1 TAIL] sqlite3_column_count $STMT } 3 | > | 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 | } do_test capi3-5.0 { execsql { CREATE TABLE t1(a VARINT, b BLOB, c VARCHAR(16)); INSERT INTO t1 VALUES(1, 2, 3); INSERT INTO t1 VALUES('one', 'two', NULL); INSERT INTO t1 VALUES(1.2, 1.3, 1.4); } set sql "SELECT * FROM t1" set STMT [sqlite3_prepare $DB $sql -1 TAIL] sqlite3_column_count $STMT } 3 |
︙ | ︙ | |||
334 335 336 337 338 339 340 341 342 | } SQLITE_ROW check_header $STMT capi3-5.6 {a b c} {VARIANT BLOB VARCHAR(16)} check_data $STMT capi3-5.7 {TEXT TEXT NULL} {0 0 0} {0 0 0} {one two {}} do_test capi3-5.8 { sqlite3_step $STMT } SQLITE_DONE | > > > > > > > | | 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 | } SQLITE_ROW check_header $STMT capi3-5.6 {a b c} {VARIANT BLOB VARCHAR(16)} check_data $STMT capi3-5.7 {TEXT TEXT NULL} {0 0 0} {0 0 0} {one two {}} do_test capi3-5.8 { sqlite3_step $STMT } SQLITE_ROW check_header $STMT capi3-5.9 {a b c} {VARIANT BLOB VARCHAR(16)} check_data $STMT capi3-5.10 {REAL REAL TEXT} {1 1 1} {1.2 1.3 1.4} {1.2 1.3 1.4} do_test capi3-5.11 { sqlite3_step $STMT } SQLITE_DONE do_test capi3-5.12 { sqlite3_finalize $STMT } SQLITE_OK db close finish_test |