Lines Matching defs:data
1078 ** We need several data types from the Windows SDK header.
1273 struct _finddata_t data;
1275 SIZE_T namesize = sizeof(data.name) / sizeof(data.name[0]);
1285 memset(&data, 0, sizeof(struct _finddata_t));
1286 _snprintf(data.name, namesize, "%s\\*", dirname);
1287 dirp->d_handle = _findfirst(data.name, &data);
1295 if( is_filtered(data) ){
1298 memset(&data, 0, sizeof(struct _finddata_t));
1299 if( _findnext(dirp->d_handle, &data)==-1 ){
1305 if( is_filtered(data) ) goto next;
1308 dirp->d_first.d_attributes = data.attrib;
1309 strncpy(dirp->d_first.d_name, data.name, NAME_MAX);
1321 struct _finddata_t data;
1334 memset(&data, 0, sizeof(struct _finddata_t));
1335 if( _findnext(dirp->d_handle, &data)==-1 ) return NULL;
1338 if( is_filtered(data) ) goto next;
1341 dirp->d_next.d_attributes = data.attrib;
1342 strncpy(dirp->d_next.d_name, data.name, NAME_MAX);
1356 struct _finddata_t data;
1375 memset(&data, 0, sizeof(struct _finddata_t));
1376 if( _findnext(dirp->d_handle, &data)==-1 ){
1382 if( is_filtered(data) ) goto next;
1385 entry->d_attributes = data.attrib;
1386 strncpy(entry->d_name, data.name, NAME_MAX);
3706 seriesColumn, /* xColumn - read data */
3707 seriesRowid, /* xRowid - read data */
4696 ** data: For a regular file, a blob containing the file data. For a
4747 #define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)"
5602 fsdirColumn, /* xColumn - read data */
5603 fsdirRowid, /* xRowid - read data */
6123 completionColumn, /* xColumn - read data */
6124 completionRowid, /* xRowid - read data */
6399 ** Read data from an apnd-file.
6441 ** Write data to an apnd-file.
6943 "rawdata," /* 4: Raw data */
6944 "data," /* 5: Uncompressed data */
6988 ** The sizes of the fixed-size part of each of the three main data
7101 u8 *aExtra; /* cds.nExtra+cds.nComment bytes of extra data */
7102 i64 iDataOff; /* Offset to data in file (if aData==0) */
7103 u8 *aData; /* cds.szCompressed bytes of compressed data */
7355 ** Read nRead bytes of data from offset iOff of file pFile into buffer
7779 ** Buffer aIn (size nIn bytes) contains compressed data. Uncompressed, the
7780 ** size is nOut bytes. This function uncompresses the data and sets the
7787 const u8 *aIn, /* Compressed data */
7822 ** Buffer aIn (size nIn bytes) contains uncompressed data. This function
7824 ** compressed data. The caller is responsible for eventually calling
7905 case 5: { /* data */
8219 /* The "extra" data */
8276 /* The "mode" attribute is a directory, but data has been specified.
8277 ** Or vice-versa - no data but "mode" is a file or symlink. */
8278 *pzErr = sqlite3_mprintf("zipfile: mode does not match data");
8312 ** structure into memory. During the transaction any new file data is
8446 /* data=NULL. A directory */
8449 /* Value specified for "data", and possibly "method". This must be
8742 void **ppArg /* OUT: User data for *pxFunc */
8785 ** SELECT zipfile(name,data) ...
8786 ** SELECT zipfile(name,mode,mtime,data) ...
8787 ** SELECT zipfile(name,mode,mtime,data,method) ...
8806 const u8 *aData = 0; /* Possibly compressed data for new entry */
8808 int szUncompressed = 0; /* Size of data before compression */
8810 u32 iCrc32 = 0; /* crc32 of uncompressed data */
8859 /* Now inspect the data. If this is NULL, then the new entry must be a
8860 ** directory. Otherwise, figure out whether or not the data should
8933 /* Append the data to the body of the new archive */
9012 zipfileColumn, /* xColumn - read data */
9013 0, /* xRowid - read data */
9093 ** compressed data.
9220 ** By default, sqlite3_expert_analyze() generates sqlite_stat1 data for
9225 ** be configured so that sqlite_stat1 data is instead generated based on a
9226 ** subset of each table, or so that no sqlite_stat1 data is used at all.
9229 ** than or equal to zero, then no sqlite_stat1 data is generated or used by
9231 ** Or, if the value is 100 or greater, complete sqlite_stat1 data is
9234 ** table rows that should be considered when generating sqlite_stat1 data.
9238 ** // Do not generate any sqlite_stat1 data
9241 ** // Generate sqlite_stat1 data based on 10% of the rows in each table.
10009 expertColumn, /* xColumn - read data */
10010 expertRowid, /* xRowid - read data */
10011 expertUpdate, /* xUpdate - write data */
10451 ** Create candidate indexes in database [dbm] based on the data in
11079 ** The stat1 data is generated by querying the
11101 /* If iSample==0, no sqlite_stat1 data is required. */
11327 /* Generate the stat1 data */
11433 ** sqlite_dbdata is used to extract data directly from a database b-tree
11474 ** error. Instead, it attempts to extract as much data as possible and
11735 ** data, (*pnPage) to the size of that buffer in bytes and return
12000 /* Figure out how much data to read from the local page */
12215 "SELECT data FROM sqlite_dbpage(?) WHERE pgno=?", -1,
12323 dbdataColumn, /* xColumn - read data */
12324 dbdataRowid, /* xRowid - read data */
12374 ** an SQLite extension designed to recover data from corrupted database
12381 ** To use the API to recover data from a corrupted database, an
12445 ** corrupt) database to recover data from. The first argument is an open
12450 ** handle, then data is recovered into a new database, identified by
12455 ** If sqlite3_recover_init_sql() is invoked, then any recovered data will
12505 ** recovered part of the schema, data is extracted from these
12515 ** are ignored. Setting this option can recover more data from the
12532 ** recovery operation - after all recoverable data has been inserted
12539 ** recovered data. This is slower overall, but avoids the slow call
12557 ** considered an error if some or all of the data cannot be recovered
12652 ** When recovering rows of data that can be associated with table
12683 ** the output database, before any non-schema data are recovered. They
12760 ** recovering data for tables identified in the recovered schema (state
12782 ** recovering data destined for the lost and found table (states
13261 ** if the page has already been used somehow during data recovery, or false
13285 ** The value returned in this case is an SQL blob containing the data for
13289 ** SELECT getpage(4); -- return page 4 of db as a blob of data
13308 p, p->dbIn, "SELECT data FROM sqlite_dbpage(%Q) WHERE pgno=?", p->zDb
13568 ** intermediate data, and to register all required user functions and
14081 ** Input database page iPg contains data that will be written to the
14120 ** Recover data from page iPage of the input database and write it to
14158 /* Discard the accumulated row data */
14199 ** table of the output database is populated with recovered data that can
14228 ** is populated with recovered data that can not be assigned to any
14263 ** recovered data.
14326 ** schema of the input database are populated with recovered data.
14473 "trunkdata(pgno, data) AS ("
14476 "freelist(data, n, freepgno) AS ("
14477 " SELECT data, min(16384, read_i32(data, 1)-1), pgno FROM trunkdata"
14479 " SELECT data, n-1, read_i32(data, 2+n) FROM freelist WHERE n>=0"
15329 ** the recovered data.
15340 ** Initialize a recovery handle that returns recovered data in the
15626 #define SHELL_OPEN_HEXDB 6 /* Use "dbtotxt" output as data source */
15652 #define SHFLG_DumpDataOnly 0x00000100 /* .dump show data only */
15674 #define MODE_Explain 9 /* Like MODE_Column, but do not truncate data */
16415 ** Add a new entry to the EXPLAIN QUERY PLAN data
16440 ** Free and reset the EXPLAIN QUERY PLAN data that has been collected
16482 ** Display and reset the EXPLAIN QUERY PLAN data
18094 /* extract the data and data types */
18111 /* if data and types extracted successfully... */
18113 /* call the supplied callback with the result row data */
18273 ** and callback data argument.
18383 ** data required to add indents to the output.*/
18768 ".clone NEWDB Clone data into NEWDB from the existing database",
18778 " --data-only Output only INSERT statements",
18808 ".import FILE TABLE Import data from FILE into TABLE",
18922 ".recover Recover as much data as possible from corrupt db.",
19095 ** For convenience, a nul-terminator byte is always appended to the data read
20038 ** Try to transfer data for table zTable. If an error is seen while
20286 ** p->zTempFile data file out from under it */
20365 "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
20417 utf8_printf(p->out, "%-20s %u\n", "data version", iDataVersion);
21371 "FROM %s WHERE (%s) AND (data IS NULL OR $dirOnly = 0)"
21375 "sqlar_uncompress(data, sz)",
21376 "data"
21484 " data BLOB -- compressed content\n"
21488 "REPLACE INTO %s(name,mode,mtime,sz,data)\n"
21494 " WHEN '-' THEN length(data)\n"
21497 " sqlar_compress(data)\n"
21501 "REPLACE INTO %s(name,mode,mtime,data)\n"
21506 " data\n"
21706 ** This function is called to recover data from the database. A script
21707 ** to construct a new database containing all recovered data is output
22398 if( cli_strcmp(z,"data-only")==0 ){
22412 ** only dump data for tables for which either the table name matches
22716 ShellState data;
22718 memcpy(&data, p, sizeof(data));
22719 data.showHeader = 0;
22720 data.cMode = data.mode = MODE_Semi;
22722 data.cMode = data.mode = MODE_Pretty;
22738 callback, &data, 0
22753 data.cMode = data.mode = MODE_Insert;
22754 data.zDestTable = "sqlite_stat1";
22755 shell_exec(&data, "SELECT * FROM sqlite_stat1", 0);
22756 data.zDestTable = "sqlite_stat4";
22757 shell_exec(&data, "SELECT * FROM sqlite_stat4", 0);
22785 char *zTable = 0; /* Insert data into this table */
23943 ShellState data;
23953 memcpy(&data, p, sizeof(data));
23954 data.showHeader = 0;
23955 data.cMode = data.mode = MODE_Semi;
23959 data.cMode = data.mode = MODE_Pretty;
23995 callback(&data, 1, new_argv, new_colv);
24068 rc = sqlite3_exec(p->db, sSelect.z, callback, &data, &zErrMsg);
25667 ShellState *p, /* Configuration data */
25792 ** Initialize the state information in data
25794 static void main_init(ShellState *data) {
25795 memset(data, 0, sizeof(*data));
25796 data->normalMode = data->cMode = data->mode = MODE_List;
25797 data->autoExplain = 1;
25798 data->pAuxDb = &data->aAuxDb[0];
25799 memcpy(data->colSeparator,SEP_Column, 2);
25800 memcpy(data->rowSeparator,SEP_Row, 2);
25801 data->showHeader = 0;
25802 data->shellFlgs = SHFLG_Lookaside;
25805 sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
25872 # define data shellState
25874 ShellState data;
25894 data.wasm.zDefaultDbName = "/fiddle.sqlite3";
25928 main_init(&data);
25975 SQLITE_SHELL_DBNAME_PROC(&data.pAuxDb->zDbFilename);
25990 if( data.aAuxDb->zDbFilename==0 ){
25991 data.aAuxDb->zDbFilename = z;
26040 data.shellFlgs |= SHFLG_Pagecache;
26048 if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
26085 data.openMode = SHELL_OPEN_ZIPFILE;
26088 data.openMode = SHELL_OPEN_APPENDVFS;
26091 data.openMode = SHELL_OPEN_DESERIALIZE;
26093 data.szMax = integerValue(argv[++i]);
26096 data.openMode = SHELL_OPEN_READONLY;
26098 data.openFlags = SQLITE_OPEN_NOFOLLOW;
26110 free(data.zNonce);
26111 data.zNonce = strdup(cmdline_option_value(argc, argv, ++i));
26144 if( data.pAuxDb->zDbFilename==0 ){
26146 data.pAuxDb->zDbFilename = ":memory:";
26153 data.out = stdout;
26163 if( access(data.pAuxDb->zDbFilename, 0)==0 ){
26164 open_db(&data, 0);
26171 process_sqliterc(&data,zInitFile);
26185 data.mode = MODE_Html;
26187 data.mode = MODE_List;
26189 data.mode = MODE_Quote;
26190 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Comma);
26191 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Row);
26193 data.mode = MODE_Line;
26195 data.mode = MODE_Column;
26197 data.mode = MODE_Json;
26199 data.mode = MODE_Markdown;
26201 data.mode = MODE_Table;
26203 data.mode = MODE_Box;
26205 data.mode = MODE_Csv;
26206 memcpy(data.colSeparator,",",2);
26209 data.openMode = SHELL_OPEN_ZIPFILE;
26212 data.openMode = SHELL_OPEN_APPENDVFS;
26215 data.openMode = SHELL_OPEN_DESERIALIZE;
26217 data.szMax = integerValue(argv[++i]);
26220 data.openMode = SHELL_OPEN_READONLY;
26222 data.openFlags |= SQLITE_OPEN_NOFOLLOW;
26224 data.mode = MODE_Ascii;
26225 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Unit);
26226 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Record);
26228 data.mode = MODE_List;
26229 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator, SEP_Tab);
26230 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator, SEP_Row);
26232 sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
26235 sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
26238 sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
26241 data.showHeader = 1;
26242 ShellSetFlag(&data, SHFLG_HeaderSet);
26244 data.showHeader = 0;
26245 ShellSetFlag(&data, SHFLG_HeaderSet);
26247 ShellSetFlag(&data, SHFLG_Echo);
26249 data.autoEQP = AUTOEQP_on;
26251 data.autoEQP = AUTOEQP_full;
26253 data.statsOn = 1;
26255 data.scanstatsOn = 1;
26262 ShellSetFlag(&data, SHFLG_Backslash);
26310 rc = do_meta_command(z, &data);
26313 open_db(&data, 0);
26314 rc = shell_exec(&data, z, &zErrMsg);
26330 open_db(&data, OPEN_DB_ZIPFILE);
26333 arDotCommand(&data, 1, argv+(i-1), argc-(i-1));
26335 arDotCommand(&data, 1, argv+i, argc-i);
26341 data.bSafeMode = data.bSafeModePersist = 1;
26347 data.cMode = data.mode;
26357 rc = do_meta_command(azCmd[i], &data);
26363 open_db(&data, 0);
26364 rc = shell_exec(&data, azCmd[i], &zErrMsg);
26410 data.in = 0;
26411 rc = process_input(&data);
26418 data.in = stdin;
26419 rc = process_input(&data);
26426 set_table_name(&data, 0);
26427 if( data.db ){
26428 session_close_all(&data, -1);
26429 close_db(data.db);
26431 for(i=0; i<ArraySize(data.aAuxDb); i++){
26432 sqlite3_free(data.aAuxDb[i].zFreeOnClose);
26433 if( data.aAuxDb[i].db ){
26434 session_close_all(&data, i);
26435 close_db(data.aAuxDb[i].db);
26439 output_reset(&data);
26440 data.doXdgOpen = 0;
26441 clearTempFile(&data);
26446 free(data.colWidth);
26447 free(data.zNonce);
26448 /* Clear the global data structure so that valgrind will detect memory
26450 memset(&data, 0, sizeof(data));