Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Use the new form of the sqlite3_create_function() API. (CVS 1460) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
0317bef4b0c219ca2888c90553201e53 |
User & Date: | danielk1977 2004-05-26 06:18:37.000 |
Context
2004-05-26
| ||
06:58 | Remove the show_datatypes pragma. (CVS 1461) (check-in: 93bb958d93 user: danielk1977 tags: trunk) | |
06:18 | Use the new form of the sqlite3_create_function() API. (CVS 1460) (check-in: 0317bef4b0 user: danielk1977 tags: trunk) | |
02:04 | Use the new API calls more consistently. (CVS 1459) (check-in: 17e7db488d user: danielk1977 tags: trunk) | |
Changes
Changes to src/date.c.
︙ | ︙ | |||
12 13 14 15 16 17 18 | ** This file contains the C functions that implement date and time ** functions for SQLite. ** ** There is only one exported symbol in this file - the function ** sqlite3RegisterDateTimeFunctions() 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 date and time ** functions for SQLite. ** ** There is only one exported symbol in this file - the function ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. ** All other code has file scope. ** ** $Id: date.c,v 1.24 2004/05/26 06:18:37 danielk1977 Exp $ ** ** NOTES: ** ** SQLite processes all times and dates as Julian Day numbers. The ** dates and times are stored as the number of days since noon ** in Greenwich on November 24, 4714 B.C. according to the Gregorian ** calendar system. |
︙ | ︙ | |||
862 863 864 865 866 867 868 | { "datetime", -1, SQLITE_TEXT, datetimeFunc }, { "strftime", -1, SQLITE_TEXT, strftimeFunc }, #endif }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ | | | | 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 | { "datetime", -1, SQLITE_TEXT, datetimeFunc }, { "strftime", -1, SQLITE_TEXT, strftimeFunc }, #endif }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, 0, 0, 0, aFuncs[i].xFunc, 0, 0); if( aFuncs[i].xFunc ){ sqlite3_function_type(db, aFuncs[i].zName, aFuncs[i].dataType); } } } |
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.56 2004/05/26 06:18:37 danielk1977 Exp $ */ #include <ctype.h> #include <math.h> #include <stdlib.h> #include <assert.h> #include "sqliteInt.h" #include "vdbeInt.h" |
︙ | ︙ | |||
664 665 666 667 668 669 670 | #endif }; static const char *azTypeFuncs[] = { "min", "max", "typeof" }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ void *pArg = aFuncs[i].argType==2 ? (void*)(-1) : db; | | | | | | 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 | #endif }; static const char *azTypeFuncs[] = { "min", "max", "typeof" }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ void *pArg = aFuncs[i].argType==2 ? (void*)(-1) : db; sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, 0, 0, pArg, aFuncs[i].xFunc, 0, 0); if( aFuncs[i].xFunc ){ sqlite3_function_type(db, aFuncs[i].zName, aFuncs[i].dataType); } } for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){ void *pArg = aAggs[i].argType==2 ? (void*)(-1) : db; sqlite3_create_function(db, aAggs[i].zName, aAggs[i].nArg, 0, 0, pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize); sqlite3_function_type(db, aAggs[i].zName, aAggs[i].dataType); } for(i=0; i<sizeof(azTypeFuncs)/sizeof(azTypeFuncs[0]); i++){ int n = strlen(azTypeFuncs[i]); FuncDef *p = sqlite3HashFind(&db->aFunc, azTypeFuncs[i], n); while( p ){ |
︙ | ︙ |
Changes to src/main.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** ** $Id: main.c,v 1.191 2004/05/26 06:18:37 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> /* ** A pointer to this structure is used to communicate information |
︙ | ︙ | |||
637 638 639 640 641 642 643 | ** Windows systems need functions to call to return the sqlite3_version ** and sqlite3_encoding strings since they are unable to access constants ** within DLLs. */ const char *sqlite3_libversion(void){ return sqlite3_version; } const char *sqlite3_libencoding(void){ return sqlite3_encoding; } | < < < < < < < < < < < < < < | | | > > > | > | > | > > > > > | > > > | | > > > | | | | > | | | | > > > > | | < < | < < | | | | > | < < | > | | 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 | ** Windows systems need functions to call to return the sqlite3_version ** and sqlite3_encoding strings since they are unable to access constants ** within DLLs. */ const char *sqlite3_libversion(void){ return sqlite3_version; } const char *sqlite3_libencoding(void){ return sqlite3_encoding; } int sqlite3_create_function( sqlite3 *db, const char *zFunctionName, int nArg, int eTextRep, int iCollateArg, void *pUserData, void (*xFunc)(sqlite3_context*,int,sqlite3_value **), void (*xStep)(sqlite3_context*,int,sqlite3_value **), void (*xFinal)(sqlite3_context*) ){ FuncDef *p; int nName; if( db==0 || zFunctionName==0 || sqlite3SafetyCheck(db) ){ return SQLITE_ERROR; } if( (xFunc && (xFinal || xStep)) || (!xFunc && (!xFinal && !xStep)) ){ return SQLITE_ERROR; } if( nArg<-1 || nArg>127 ){ return SQLITE_ERROR; } nName = strlen(zFunctionName); if( nName>255 ){ return SQLITE_ERROR; } p = sqlite3FindFunction(db, zFunctionName, nName, nArg, 1); if( p==0 ) return 1; p->xFunc = xFunc; p->xStep = xStep; p->xFinalize = xFinal; p->pUserData = pUserData; return SQLITE_OK; } int sqlite3_create_function16( sqlite3 *db, const void *zFunctionName, int nArg, int eTextRep, int iCollateArg, void *pUserData, void (*xFunc)(sqlite3_context*,int,sqlite3_value**), void (*xStep)(sqlite3_context*,int,sqlite3_value**), void (*xFinal)(sqlite3_context*) ){ int rc; char *zFunctionName8; zFunctionName8 = sqlite3utf16to8(zFunctionName, -1, SQLITE3_BIGENDIAN); if( !zFunctionName8 ){ return SQLITE_NOMEM; } rc = sqlite3_create_function(db, zFunctionName8, nArg, eTextRep, iCollateArg, pUserData, xFunc, xStep, xFinal); sqliteFree(zFunctionName8); return rc; } /* ** Change the datatype for all functions with a given name. See the ** header comment for the prototype of this function in sqlite.h for ** additional information. */ |
︙ | ︙ |
Changes to src/md5.c.
︙ | ︙ | |||
378 379 380 381 382 383 384 | char zBuf[33]; p = sqlite3_get_context(context, sizeof(*p)); MD5Final(digest,p); DigestToBase16(digest, zBuf); sqlite3_result_text(context, zBuf, -1, 1); } void Md5_Register(sqlite *db){ | | | 378 379 380 381 382 383 384 385 386 387 388 389 | char zBuf[33]; p = sqlite3_get_context(context, sizeof(*p)); MD5Final(digest,p); DigestToBase16(digest, zBuf); sqlite3_result_text(context, zBuf, -1, 1); } void Md5_Register(sqlite *db){ sqlite3_create_function(db, "md5sum", -1, 0, 0, 0, 0, md5step, md5finalize); } |
Changes to src/select.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 C code routines that are called by the parser ** to handle SELECT statements 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 C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** ** $Id: select.c,v 1.176 2004/05/26 06:18:38 danielk1977 Exp $ */ #include "sqliteInt.h" /* ** Allocate a new Select structure and return a pointer to that ** structure. |
︙ | ︙ | |||
1268 1269 1270 1271 1272 1273 1274 1275 1276 | int eDest, int iParm, char *aff /* If eDest is SRT_Union, the affinity string */ ){ int rc = SQLITE_OK; /* Success code from a subroutine */ Select *pPrior; /* Another SELECT immediately to our left */ Vdbe *v; /* Generate code to this VDBE */ char *affStr = 0; | > < | 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 | int eDest, int iParm, char *aff /* If eDest is SRT_Union, the affinity string */ ){ int rc = SQLITE_OK; /* Success code from a subroutine */ Select *pPrior; /* Another SELECT immediately to our left */ Vdbe *v; /* Generate code to this VDBE */ #if 0 /* NOT USED */ char *affStr = 0; if( !aff ){ int len; rc = fillInColumnList(pParse, p); if( rc!=SQLITE_OK ){ goto multi_select_end; } len = p->pEList->nExpr+1; |
︙ | ︙ |
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.80 2004/05/26 06:18:38 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++. |
︙ | ︙ | |||
53 54 55 56 57 58 59 60 61 62 63 64 65 66 | extern const char sqlite3_encoding[]; /* ** Each open sqlite database is represented by an instance of the ** following opaque structure. */ typedef struct sqlite sqlite; /* ** A function to close the database. ** ** Call this function with a pointer to a structure that was previously ** returned from sqlite3_open() and the corresponding database will by closed. */ | > > | 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 | extern const char sqlite3_encoding[]; /* ** Each open sqlite database is represented by an instance of the ** following opaque structure. */ typedef struct sqlite sqlite; typedef struct sqlite sqlite3; /* ** A function to close the database. ** ** Call this function with a pointer to a structure that was previously ** returned from sqlite3_open() and the corresponding database will by closed. */ |
︙ | ︙ | |||
413 414 415 416 417 418 419 | /* ** 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); | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | 415 416 417 418 419 420 421 422 423 424 425 426 427 428 | /* ** 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); /* ** This routine registers a callback with the SQLite library. The ** callback is invoked (at compile-time, not at run-time) for each ** attempt to access a column of a table in the database. The callback ** returns SQLITE_OK if access is allowed, SQLITE_DENY if the entire ** SQL statement should be aborted with an error and SQLITE_IGNORE ** if the column should be treated as a NULL value. |
︙ | ︙ | |||
643 644 645 646 647 648 649 650 | ** encoding, -1 is returned. ** ** The "in" and "out" parameters may point to the same buffer in order ** to decode a string in place. */ int sqlite_decode_binary(const unsigned char *in, unsigned char *out); | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 590 591 592 593 594 595 596 597 598 599 600 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 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 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 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 | ** encoding, -1 is returned. ** ** The "in" and "out" parameters may point to the same buffer in order ** to decode a string in place. */ int sqlite_decode_binary(const unsigned char *in, unsigned char *out); /* ** Open the sqlite database file "filename", where "filename" is UTF-8 ** encoded. An sqlite3* handle is returned in *ppDb, even if an error ** occurs. If the database is opened (or created) successfully, then ** SQLITE_OK is returned. Otherwise an error code is returned and the ** sqlite3_errmsg() function may be used to obtain an English language ** explanation of the error. ** ** If the database file does not exist, then a new database is created ** using UTF-8 text encoding. ** ** Whether or not an error occurs when it is opened, resources associated ** with the sqlite3* handle should be released by passing it to ** sqlite3_close() when it is no longer required. */ int sqlite3_open( const char *filename, /* Database filename (UTF-8) */ sqlite3 **ppDb, /* OUT: SQLite db handle */ const char **args /* Null terminated array of option strings */ ); /* ** Open the sqlite database file "filename", where "filename" is native ** byte order UTF-16 encoded. An sqlite3* handle is returned in *ppDb, even ** if an error occurs. If the database is opened (or created) successfully, ** then SQLITE_OK is returned. Otherwise an error code is returned and the ** sqlite3_errmsg() function may be used to obtain an English language ** explanation of the error. ** ** If the database file does not exist, then a new database is created ** using UTF-16 text encoding in the machines native byte order. ** ** Whether or not an error occurs when it is opened, resources associated ** with the sqlite3* handle should be released by passing it to ** sqlite3_close() when it is no longer required. */ int sqlite3_open16( const void *filename, /* Database filename (UTF-16) */ sqlite3 **ppDb, /* OUT: SQLite db handle */ const char **args /* Null terminated array of option strings */ ); /* ** Return the error code for the most recent sqlite3_* API call associated ** with sqlite3 handle 'db'. SQLITE_OK is returned if the most recent ** API call was successful. ** ** Calls to many sqlite3_* functions set the error code and string returned ** by sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16() ** (overwriting the previous values). Note that calls to sqlite3_errcode(), ** sqlite3_errmsg() and sqlite3_errmsg16() themselves do not affect the ** results of future invocations. ** ** Assuming no other intervening sqlite3_* API calls are made, the error ** code returned by this function is associated with the same error as ** the strings returned by sqlite3_errmsg() and sqlite3_errmsg16(). */ int sqlite3_errcode(sqlite3 *db); /* ** Return a pointer to a UTF-8 encoded string describing in english the ** error condition for the most recent sqlite3_* API call. The returned ** string is always terminated by an 0x00 byte. ** ** The string "not an error" is returned when the most recent API call was ** successful. */ const char *sqlite3_errmsg(sqlite3*); /* ** Return a pointer to a UTF-16 native byte order encoded string describing ** in english the error condition for the most recent sqlite3_* API call. ** The returned string is always terminated by a pair of 0x00 bytes. ** ** The string "not an error" is returned when the most recent API call was ** successful. */ const void *sqlite3_errmsg16(sqlite3*); /* ** An instance of the following opaque structure is used to represent ** a compiled SQL statment. */ typedef struct sqlite3_stmt sqlite3_stmt; /* ** To execute an SQL query, it must first be compiled into a byte-code ** program using one of the following routines. The only difference between ** them is that the second argument, specifying the SQL statement to ** compile, is assumed to be encoded in UTF-8 for the sqlite3_prepare() ** function and UTF-16 for sqlite3_prepare16(). ** ** The first parameter "db" is an SQLite database handle. The second ** parameter "zSql" is the statement to be compiled, encoded as either ** UTF-8 or UTF-16 (see above). If the next parameter, "nBytes", is less ** than zero, then zSql is read up to the first nul terminator. If ** "nBytes" is not less than zero, then it is the length of the string zSql ** in bytes (not characters). ** ** *pzTail is made to point to the first byte past the end of the first ** SQL statement in zSql. This routine only compiles the first statement ** in zSql, so *pzTail is left pointing to what remains uncompiled. ** ** *ppStmt is left pointing to a compiled SQL statement that can be ** executed using sqlite3_step(). Or if there is an error, *ppStmt may be ** set to NULL. If the input text contained no SQL (if the input is and ** empty string or a comment) then *ppStmt is set to NULL. ** ** On success, SQLITE_OK is returned. Otherwise an error code is returned. */ int sqlite3_prepare( sqlite3 *db, /* Database handle */ const char *zSql, /* SQL statement, UTF-8 encoded */ int nBytes, /* Length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const char **pzTail /* OUT: Pointer to unused portion of zSql */ ); int sqlite3_prepare16( sqlite3 *db, /* Database handle */ const void *zSql, /* SQL statement, UTF-16 encoded */ int nBytes, /* Length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const void **pzTail /* OUT: Pointer to unused portion of zSql */ ); /* ** Return the number of columns in the result set returned by the compiled ** SQL statement. This routine returns 0 if pStmt is an SQL statement ** that does not return data (for example an UPDATE). */ int sqlite3_column_count(sqlite3_stmt *pStmt); /* ** The first parameter is a compiled SQL statement. This function returns ** the column heading for the Nth column of that statement, where N is the ** second function parameter. The string returned is UTF-8 encoded. */ const char *sqlite3_column_name(sqlite3_stmt*,int); /* ** The first parameter is a compiled SQL statement. This function returns ** the column heading for the Nth column of that statement, where N is the ** second function parameter. The string returned is UTF-16 encoded. */ const void *sqlite3_column_name16(sqlite3_stmt*,int); /* ** The first parameter is a compiled SQL statement. If this statement ** is a SELECT statement, the Nth column of the returned result set ** of the SELECT is a table column then the declared type of the table ** column is returned. If the Nth column of the result set is not at table ** column, then a NULL pointer is returned. The returned string is always ** UTF-8 encoded. For example, in the database schema: ** ** CREATE TABLE t1(c1 VARIANT); ** ** And the following statement compiled: ** ** SELECT c1 + 1, 0 FROM t1; ** ** Then this routine would return the string "VARIANT" for the second ** result column (i==1), and a NULL pointer for the first result column ** (i==0). */ const char *sqlite3_column_decltype(sqlite3_stmt *, int i); /* ** The first parameter is a compiled SQL statement. If this statement ** is a SELECT statement, the Nth column of the returned result set ** of the SELECT is a table column then the declared type of the table ** column is returned. If the Nth column of the result set is not at table ** column, then a NULL pointer is returned. The returned string is always ** UTF-16 encoded. For example, in the database schema: ** ** CREATE TABLE t1(c1 VARINT); ** ** And the following statement compiled: ** ** SELECT c1 + 1, 0 FROM t1; ** ** Then this routine would return the string "VARIANT" for the second ** result column (i==1), and a NULL pointer for the first result column ** (i==0). */ const void *sqlite3_column_decltype16(sqlite3_stmt*,int); /* ** This routine is used to bind a 32-bit integer value to a variable ** in an SQL statement compiled by sqlite3_prepare(). See comments for ** sqlite3_prepare() for more details on SQL statement variables. ** ** The first argument is a pointer to an SQL statement previously ** obtained from a call to sqlite3_prepare(). The second parameter "i" |
︙ | ︙ | |||
761 762 763 764 765 766 767 | ** pointed to by "z". If "eCopy" is false, then SQLite stores a pointer to ** the original blob data. In this case the caller must ensure that the ** blob data remains stable until after the SQL statement has been ** finalised or another value bound to variable "i". */ int sqlite3_bind_blob(sqlite3_stmt*, int i, const void *z, int n, int eCopy); | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | 889 890 891 892 893 894 895 896 897 898 899 900 901 902 | ** pointed to by "z". If "eCopy" is false, then SQLite stores a pointer to ** the original blob data. In this case the caller must ensure that the ** blob data remains stable until after the SQL statement has been ** finalised or another value bound to variable "i". */ int sqlite3_bind_blob(sqlite3_stmt*, int i, const void *z, int n, int eCopy); /* ** After an SQL query has been compiled with a call to either ** sqlite3_prepare() or sqlite3_prepare16(), then this function must be ** called one or more times to execute the statement. ** ** The return value will be either SQLITE_BUSY, SQLITE_DONE, ** SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE. |
︙ | ︙ | |||
966 967 968 969 970 971 972 | ** Perhaps it was called on a virtual machine that had already been ** finalized or on one that had previously returned SQLITE_ERROR or ** SQLITE_DONE. Or it could be the case the the same database connection ** is being used simulataneously by two or more threads. */ int sqlite3_step(sqlite3_stmt*); | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | 923 924 925 926 927 928 929 930 931 932 933 934 935 936 | ** Perhaps it was called on a virtual machine that had already been ** finalized or on one that had previously returned SQLITE_ERROR or ** SQLITE_DONE. Or it could be the case the the same database connection ** is being used simulataneously by two or more threads. */ int sqlite3_step(sqlite3_stmt*); /* ** Return the number of values in the current row of the result set. ** ** After a call to sqlite3_step() that returns SQLITE_ROW, this routine ** will return the same value as the sqlite3_column_count() function. ** After sqlite3_step() has returned an SQLITE_DONE, SQLITE_BUSY or ** error code, or before sqlite3_step() has been called on a |
︙ | ︙ | |||
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 | ** SQLITE3_INTEGER The value of the integer. Some rounding may occur. ** SQLITE3_FLOAT The value of the float. ** SQLITE3_TEXT Real number conversion of string, or 0.0 ** SQLITE3_BLOB 0.0 */ double sqlite3_column_float(sqlite3_stmt*,int); /* ** Return the type of the sqlite3_value* passed as the first argument. ** The type is one of SQLITE3_NULL, SQLITE3_INTEGER, SQLITE3_FLOAT, ** SQLITE3_TEXT or SQLITE3_BLOB. */ int sqlite3_value_type(sqlite3_value*); | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 | ** SQLITE3_INTEGER The value of the integer. Some rounding may occur. ** SQLITE3_FLOAT The value of the float. ** SQLITE3_TEXT Real number conversion of string, or 0.0 ** SQLITE3_BLOB 0.0 */ double sqlite3_column_float(sqlite3_stmt*,int); /* ** The sqlite3_finalize() function is called to delete a compiled ** SQL statement obtained by a previous call to sqlite3_prepare() ** or sqlite3_prepare16(). If the statement was executed successfully, or ** not executed at all, then SQLITE_OK is returned. If execution of the ** statement failed then an error code is returned. ** ** This routine can be called at any point during the execution of the ** virtual machine. If the virtual machine has not completed execution ** when this routine is called, that is like encountering an error or ** an interrupt. (See sqlite3_interrupt().) Incomplete updates may be ** rolled back and transactions cancelled, depending on the circumstances, ** and the result code returned will be SQLITE_ABORT. */ int sqlite3_finalize(sqlite3_stmt *pStmt); /* ** The sqlite3_reset() function is called to reset a compiled SQL ** statement obtained by a previous call to sqlite3_prepare() or ** sqlite3_prepare16() back to it's initial state, ready to be re-executed. ** Any SQL statement variables that had values bound to them using ** the sqlite3_bind_*() API retain their values. */ int sqlite3_reset(sqlite3_stmt *pStmt); /* ** Pointers to the following two opaque structures are used to communicate ** with the implementations of user-defined functions. */ typedef struct sqlite3_context sqlite3_context; typedef struct Mem sqlite3_value; /* ** The following two functions are used to add user functions or aggregates ** implemented in C to the SQL langauge interpreted by SQLite. The ** difference only between the two is that the second parameter, the ** name of the (scalar) function or aggregate, is encoded in UTF-8 for ** sqlite3_create_function() and UTF-16 for sqlite3_create_function16(). ** ** The first argument is the database handle that the new function or ** aggregate is to be added to. If a single program uses more than one ** database handle internally, then user functions or aggregates must ** be added individually to each database handle with which they will be ** used. ** ** The third parameter is the number of arguments that the function or ** aggregate takes. If this parameter is negative, then the function or ** aggregate may take any number of arguments. ** ** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are ** pointers to user implemented C functions that implement the user ** function or aggregate. A scalar function requires an implementation of ** the xFunc callback only, NULL pointers should be passed as the xStep ** and xFinal parameters. An aggregate function requires an implementation ** of xStep and xFinal, but NULL should be passed for xFunc. To delete an ** existing user function or aggregate, pass NULL for all three function ** callback. Specifying an inconstent set of callback values, such as an ** xFunc and an xFinal, or an xStep but no xFinal, SQLITE_ERROR is ** returned. */ int sqlite3_create_function( sqlite3 *, const char *zFunctionName, int nArg, int eTextRep, int iCollateArg, void*, void (*xFunc)(sqlite3_context*,int,sqlite3_value**), void (*xStep)(sqlite3_context*,int,sqlite3_value**), void (*xFinal)(sqlite3_context*) ); int sqlite3_create_function16( sqlite3*, const void *zFunctionName, int nArg, int eTextRep, int iCollateArg, void*, void (*xFunc)(sqlite3_context*,int,sqlite3_value**), void (*xStep)(sqlite3_context*,int,sqlite3_value**), void (*xFinal)(sqlite3_context*) ); /* ** Use the following routine to define the datatype returned by a ** user-defined function. The second argument can be one of the ** constants SQLITE_NUMERIC, SQLITE_TEXT, or SQLITE_ARGS or it ** can be an integer greater than or equal to zero. When the datatype ** parameter is non-negative, the type of the result will be the ** same as the datatype-th argument. If datatype==SQLITE_NUMERIC ** then the result is always numeric. If datatype==SQLITE_TEXT then ** the result is always text. If datatype==SQLITE_ARGS then the result ** is numeric if any argument is numeric and is text otherwise. */ int sqlite3_function_type( sqlite *db, /* The database there the function is registered */ const char *zName, /* Name of the function */ int datatype /* The datatype for this function */ ); #define SQLITE_NUMERIC (-1) #define SQLITE_TEXT (-2) #define SQLITE_ARGS (-3) /* ** The next routine returns the number of calls to xStep for a particular ** aggregate function instance. The current call to xStep counts so this ** routine always returns at least 1. */ int sqlite3_aggregate_count(sqlite3_context*); /* ** Return the type of the sqlite3_value* passed as the first argument. ** The type is one of SQLITE3_NULL, SQLITE3_INTEGER, SQLITE3_FLOAT, ** SQLITE3_TEXT or SQLITE3_BLOB. */ int sqlite3_value_type(sqlite3_value*); |
︙ | ︙ |
Changes to src/tclsqlite.c.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2001 September 15 ** ** 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. ** ************************************************************************* ** A TCL Interface to SQLite ** | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* ** 2001 September 15 ** ** 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. ** ************************************************************************* ** A TCL Interface to SQLite ** ** $Id: tclsqlite.c,v 1.71 2004/05/26 06:18:38 danielk1977 Exp $ */ #ifndef NO_TCL /* Omit this whole file if TCL is unavailable */ #include "sqliteInt.h" #include "tcl.h" #include <stdlib.h> #include <string.h> |
︙ | ︙ | |||
859 860 861 862 863 864 865 | zScript = Tcl_GetStringFromObj(objv[3], &nScript); pFunc = (SqlFunc*)Tcl_Alloc( sizeof(*pFunc) + nScript + 1 ); if( pFunc==0 ) return TCL_ERROR; pFunc->interp = interp; pFunc->pNext = pDb->pFunc; pFunc->zScript = (char*)&pFunc[1]; strcpy(pFunc->zScript, zScript); | | | 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 | zScript = Tcl_GetStringFromObj(objv[3], &nScript); pFunc = (SqlFunc*)Tcl_Alloc( sizeof(*pFunc) + nScript + 1 ); if( pFunc==0 ) return TCL_ERROR; pFunc->interp = interp; pFunc->pNext = pDb->pFunc; pFunc->zScript = (char*)&pFunc[1]; strcpy(pFunc->zScript, zScript); sqlite3_create_function(pDb->db, zName, -1, 0, 0, pFunc, tclSqlFunc, 0, 0); sqlite3_function_type(pDb->db, zName, SQLITE_NUMERIC); break; } /* ** $db last_insert_rowid ** |
︙ | ︙ |
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 | ** 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.55 2004/05/26 06:18:38 danielk1977 Exp $ */ #include "sqliteInt.h" #include "tcl.h" #include "os.h" #include <stdlib.h> #include <string.h> |
︙ | ︙ | |||
404 405 406 407 408 409 410 | extern void Md5_Register(sqlite*); if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " FILENAME\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; | | | > | 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 | extern void Md5_Register(sqlite*); if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " FILENAME\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; sqlite3_create_function(db, "x_coalesce", -1, 0, 0, 0, ifnullFunc, 0, 0); sqlite3_create_function(db, "x_sqlite3_exec", 1, 0, 0, db, sqlite3ExecFunc, 0, 0); return TCL_OK; } /* ** Routines to implement the x_count() aggregate function. */ typedef struct CountCtx CountCtx; |
︙ | ︙ | |||
453 454 455 456 457 458 459 | sqlite *db; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " FILENAME\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; | | | | 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 | sqlite *db; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " FILENAME\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; sqlite3_create_function(db, "x_count", 0, 0, 0, 0, 0,countStep,countFinalize); sqlite3_create_function(db, "x_count", 1, 0, 0, 0, 0,countStep,countFinalize); return TCL_OK; } /* ** Usage: sqlite3_mprintf_int FORMAT INTEGER INTEGER INTEGER |
︙ | ︙ | |||
682 683 684 685 686 687 688 | int rc; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB FUNCTION-NAME", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; | | | 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 | int rc; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB FUNCTION-NAME", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; rc = sqlite3_create_function(db, argv[2], -1, 0, 0, 0, testFunc, 0, 0); if( rc!=0 ){ Tcl_AppendResult(interp, sqlite3_error_string(rc), 0); return TCL_ERROR; } return TCL_OK; } |
︙ | ︙ | |||
1358 1359 1360 1361 1362 1363 1364 | return TCL_ERROR; } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; rc = sqlite3_step(pStmt); if( rc!=SQLITE_DONE && rc!=SQLITE_ROW ) return TCL_ERROR; | | | 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 | return TCL_ERROR; } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; rc = sqlite3_step(pStmt); if( rc!=SQLITE_DONE && rc!=SQLITE_ROW ) return TCL_ERROR; Tcl_SetResult(interp, (char *)errorName(rc), 0); return TCL_OK; } /* ** Usage: sqlite3_column_data STMT column ** ** Advance the statement to the next row. |
︙ | ︙ |
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.332 2004/05/26 06:18:38 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include "vdbeInt.h" /* |
︙ | ︙ | |||
570 571 572 573 574 575 576 | ** pVal. The MEM_Utf8, MEM_Utf16le and MEM_Utf16be flags must be set ** correctly when this function is called. If a translation occurs, ** the flags are set to reflect the new encoding of the string. ** ** If a translation fails because of a malloc() failure, a NULL pointer ** is returned. */ | | | 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 | ** pVal. The MEM_Utf8, MEM_Utf16le and MEM_Utf16be flags must be set ** correctly when this function is called. If a translation occurs, ** the flags are set to reflect the new encoding of the string. ** ** If a translation fails because of a malloc() failure, a NULL pointer ** is returned. */ const unsigned char *sqlite3_value_data(sqlite3_value *pVal){ if( pVal->flags&MEM_Null ){ /* For a NULL return a NULL Pointer */ return 0; } if( pVal->flags&MEM_Str ){ /* If there is already a string representation, make sure it is in |
︙ | ︙ |