Lines Matching defs:iDb
16670 #define OP_ReopenIdx 101 /* synopsis: root=P2 iDb=P3 */
16681 #define OP_OpenRead 112 /* synopsis: root=P2 iDb=P3 */
16682 #define OP_OpenWrite 113 /* synopsis: root=P2 iDb=P3 */
16716 #define OP_CreateBtree 147 /* synopsis: r[P2]=root iDb=P1 flags=P3 */
16738 #define OP_TableLock 169 /* synopsis: iDb=P1 root=P2 write=P3 */
17623 u8 iDb; /* Which db file is being initialized */
19618 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
20076 int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
20891 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
21094 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
21284 SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3*,int iDB);
23094 i8 iDb; /* Index of cursor database in db->aDb[] */
36941 /* 101 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"),
36952 /* 112 */ "OpenRead" OpHelp("root=P2 iDb=P3"),
36953 /* 113 */ "OpenWrite" OpHelp("root=P2 iDb=P3"),
36987 /* 147 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"),
37009 /* 169 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"),
53271 int iDb;
53289 iDb = sqlite3FindDbName(db, zSchema);
53291 if( iDb<0 ) return 0;
53304 pBt = db->aDb[iDb].pBt;
53357 int iDb;
53369 iDb = sqlite3FindDbName(db, zSchema);
53370 testcase( iDb==1 );
53371 if( iDb<2 && iDb!=0 ){
53383 db->init.iDb = (u8)iDb;
70114 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
70118 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
70120 ** If pSchema is not NULL, then iDb is computed from pSchema and
70123 SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
70127 if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
70128 assert( iDb>=0 && iDb<db->nDb );
70130 if( iDb==1 ) return 1;
70131 p = db->aDb[iDb].pBt;
72756 int iDb;
72757 for(iDb=db->nDb-1; iDb>=0; iDb--){
72758 Btree *pExisting = db->aDb[iDb].pBt;
74325 int iDb;
74326 for(iDb=0; ALWAYS(iDb<db->nDb); iDb++){
74327 if( db->aDb[iDb].pBt==p ) break;
74331 db->aDb[iDb].zDbSName,
84934 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){
84936 sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
96730 int iDb;
96734 iDb = pOp->p1;
96737 assert( iDb>=0 && iDb<db->nDb );
96738 assert( db->aDb[iDb].pBt!=0 );
96739 assert( DbMaskTest(p->btreeMask, iDb) );
96741 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
96795 ** Synopsis: root=P2 iDb=P3
96823 ** Synopsis: root=P2 iDb=P3
96845 ** Synopsis: root=P2 iDb=P3
96882 int iDb;
96892 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
96915 iDb = pOp->p3;
96916 assert( iDb>=0 && iDb<db->nDb );
96917 assert( DbMaskTest(p->btreeMask, iDb) );
96918 pDb = &db->aDb[iDb];
96924 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
96959 pCur->iDb = iDb;
98283 assert( pC->iDb>=0 );
98284 zDb = db->aDb[pC->iDb].zDbSName;
98444 assert( pC->iDb>=0 );
98446 zDb = db->aDb[pC->iDb].zDbSName;
98504 assert( pC->iDb>=0 );
99394 int iDb;
99406 iDb = pOp->p3;
99407 assert( DbMaskTest(p->btreeMask, iDb) );
99409 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
99415 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
99417 assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
99418 resetSchemaOnFault = iDb+1;
99488 ** Synopsis: r[P2]=root iDb=P1 flags=P3
99566 int iDb;
99576 for(iDb=0; iDb<db->nDb; iDb++){
99577 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
99581 iDb = pOp->p1;
99582 assert( iDb>=0 && iDb<db->nDb );
99583 assert( DbHasProperty(db, iDb, DB_SchemaLoaded)
99589 sqlite3SchemaClear(db->aDb[iDb].pSchema);
99591 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
99599 initData.iDb = iDb;
99602 initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt);
99605 db->aDb[iDb].zDbSName, zSchema, pOp->p4.z);
100631 ** Synopsis: iDb=P1 root=P2 write=P3
102018 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
102021 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
102029 sqlite3VdbeUsesBtree(v, iDb);
102037 aOp[0].p1 = iDb;
102049 aOp[1].p3 = iDb;
105243 int iDb = pOp->p3;
105246 pSchema = db->aDb[iDb].pSchema;
105247 pCur->zSchema = db->aDb[iDb].zDbSName;
106439 ** pExpr->iDb Set the index in db->aDb[] of the database X
111424 int iDb; /* Database idx for pTab */
111434 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
111435 assert( iDb>=0 && iDb<SQLITE_MAX_DB );
111436 sqlite3CodeVerifySchema(pParse, iDb);
111437 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
111445 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
111529 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
115518 ** Generate code to reload the schema for database iDb. And, if iDb!=1, for
115521 static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
115524 sqlite3ChangeCookie(pParse, iDb);
115525 sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
115526 if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
115539 int iDb; /* Database that contains the table */
115540 char *zDb; /* Name of database iDb */
115555 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
115556 zDb = db->aDb[iDb].zDbSName;
115563 ** in database iDb. If so, this is an error.
115610 /* Begin a transaction for database iDb. Then modify the schema cookie
115631 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
115666 if( iDb!=1 ){
115691 renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);
115692 renameTestSchema(pParse, zDb, iDb==1, "after rename", 0);
115726 int iDb; /* Database number */
115744 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
115745 zDb = db->aDb[iDb].zDbSName;
115845 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
115846 sqlite3VdbeUsesBtree(v, iDb);
115850 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
115854 renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd);
115896 int iDb;
115927 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
115958 pNew->pSchema = db->aDb[iDb].pSchema;
116559 db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);
116583 db->init.iDb = 0;
117567 int iDb; /* Index of db containing pTab in aDb[] */
117613 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
117614 assert( iDb>=0 );
117615 zDb = db->aDb[iDb].zDbSName;
117622 renameTestSchema(pParse, zDb, iDb==1, "", 0);
117623 renameFixQuotes(pParse, zDb, iDb==1);
117628 , zDb, iDb, iCol, pTab->zName
117632 renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop);
117633 renameTestSchema(pParse, zDb, iDb==1, "after drop column", 1);
117646 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
117887 int iDb, /* The database we are looking in */
117919 pDb = &db->aDb[iDb];
117945 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
117957 sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb);
117965 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, (int)aRoot[i], iDb, 3);
118710 int iDb; /* Index of database containing pTab */
118744 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
118745 assert( iDb>=0 );
118746 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
118749 db->aDb[iDb].zDbSName ) ){
118770 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
118774 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
118839 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
118840 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
119089 static void loadAnalysis(Parse *pParse, int iDb){
119092 sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
119099 static void analyzeDatabase(Parse *pParse, int iDb){
119101 Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
119107 sqlite3BeginWriteOperation(pParse, 0, iDb);
119110 openStatTable(pParse, iDb, iStatCur, 0, 0);
119113 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
119123 loadAnalysis(pParse, iDb);
119132 int iDb;
119137 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
119138 sqlite3BeginWriteOperation(pParse, 0, iDb);
119142 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
119144 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
119147 loadAnalysis(pParse, iDb);
119164 int iDb;
119186 }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
119188 analyzeDatabase(pParse, iDb);
119191 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
119192 if( iDb>=0 ){
119193 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
119653 SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
119658 Schema *pSchema = db->aDb[iDb].pSchema;
119661 assert( iDb>=0 && iDb<db->nDb );
119662 assert( db->aDb[iDb].pBt!=0 );
119665 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
119681 sInfo.zDatabase = db->aDb[iDb].zDbSName;
119696 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
119776 ** database iDb attached to handle db.
119778 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
119780 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
119781 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
119797 ** new database, close the database on db->init.iDb and reopen it as an
119832 ** from sqlite3_deserialize() to close database db->init.iDb and
119844 pNew = &db->aDb[db->init.iDb];
119948 db->init.iDb = 0;
119967 int iDb = db->nDb - 1;
119968 assert( iDb>=2 );
119969 if( db->aDb[iDb].pBt ){
119970 sqlite3BtreeClose(db->aDb[iDb].pBt);
119971 db->aDb[iDb].pBt = 0;
119972 db->aDb[iDb].pSchema = 0;
119975 db->nDb = iDb;
120203 int iDb = sqlite3FindDbName(db, pFix->zDb);
120210 if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
120248 int iDb, /* This is the database that must be used */
120253 assert( db->nDb>iDb );
120255 pFix->zDb = db->aDb[iDb].zDbSName;
120256 pFix->pSchema = db->aDb[iDb].pSchema;
120259 pFix->bTemp = (iDb==1);
120454 int iDb /* Index of containing database. */
120457 char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
120468 if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
120495 int iDb; /* The index of the database the expression refers to */
120501 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
120502 if( iDb<0 ){
120531 assert( iDb>=0 && iDb<pParse->db->nDb );
120532 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
120650 int iDb; /* The database containing the table to be locked */
120659 ** The table to be locked has root page iTab and is found in database iDb.
120668 int iDb, /* Index of the database containing the table to lock */
120677 assert( iDb>=0 );
120682 if( p->iDb==iDb && p->iTab==iTab ){
120693 p->iDb = iDb;
120704 int iDb, /* Index of the database containing the table to lock */
120709 if( iDb==1 ) return;
120710 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
120711 lockTable(pParse, iDb, iTab, isWriteLock, zName);
120725 int p1 = p->iDb;
120760 int iDb, i;
120829 iDb = 0;
120832 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
120833 sqlite3VdbeUsesBtree(v, iDb);
120834 pSchema = db->aDb[iDb].pSchema;
120837 iDb, /* P1 */
120838 DbMaskTest(pParse->writeMask,iDb), /* P2 */
120845 }while( ++iDb
121119 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
121120 zDb = pParse->db->aDb[iDb].zDbSName;
121190 ** For the index called zIdxName which is found in the database iDb,
121195 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
121199 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121200 pHash = &db->aDb[iDb].pSchema->idxHash;
121251 ** Reset the schema for the database at index iDb. Also reset the
121253 ** Deferred resets may be run by calling with iDb<0.
121255 SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
121257 assert( iDb<db->nDb );
121259 if( iDb>=0 ){
121260 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121261 DbSetProperty(db, iDb, DB_ResetWanted);
121502 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
121507 assert( iDb>=0 && iDb<db->nDb );
121509 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121511 pDb = &db->aDb[iDb];
121542 ** Open the sqlite_schema table stored in database number iDb for
121545 SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){
121547 sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE);
121548 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
121611 int iDb; /* Database holding the object */
121621 iDb = sqlite3FindDb(db, pName1);
121622 if( iDb<0 ){
121627 assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
121629 iDb = db->init.iDb;
121632 return iDb;
121842 int iDb; /* Database number to create the table in */
121847 iDb = db->init.iDb;
121848 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
121852 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
121853 if( iDb<0 ) return;
121854 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
121860 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
121871 if( db->init.iDb==1 ) isTemp = 1;
121882 char *zDb = db->aDb[iDb].zDbSName;
121901 char *zDb = db->aDb[iDb].zDbSName;
121912 sqlite3CodeVerifySchema(pParse, iDb);
121932 pTable->pSchema = db->aDb[iDb].pSchema;
121956 sqlite3BeginWriteOperation(pParse, 1, iDb);
121970 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
121971 sqlite3VdbeUsesBtree(v, iDb);
121975 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
121976 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
121996 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
121998 sqlite3OpenSchemaTable(pParse, iDb);
122357 int isInit = db->init.busy && db->init.iDb!=1;
122533 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
122666 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
122669 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122670 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
122671 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
123251 int iDb; /* Database in which the table lives */
123339 iDb = sqlite3SchemaToIndex(db, p->pSchema);
123459 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
123509 db->aDb[iDb].zDbSName,
123518 sqlite3ChangeCookie(pParse, iDb);
123525 Db *pDb = &db->aDb[iDb];
123526 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
123537 sqlite3VdbeAddParseSchemaOp(v, iDb,
123545 db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
123549 db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
123557 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
123574 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
123611 int iDb;
123632 iDb = sqlite3SchemaToIndex(db, p->pSchema);
123633 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
123840 ** root-page of a table or index in database iDb has changed from iFrom
123855 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){
123860 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
123861 pDb = &db->aDb[iDb];
123880 ** Write code to erase the table with root-page iTable from database iDb.
123885 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
123889 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
123904 pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
123952 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
123953 assert( iDb>=0 && iDb<pParse->db->nDb );
123954 destroyRootPage(pParse, iLargest, iDb);
123966 int iDb, /* The database number */
123971 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
123987 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
123991 Db *pDb = &db->aDb[iDb];
123995 sqlite3BeginWriteOperation(pParse, 1, iDb);
124048 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
124051 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
124052 sqlite3ChangeCookie(pParse, iDb);
124053 sqliteViewResetAll(db, iDb);
124099 int iDb;
124119 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
124120 assert( iDb>=0 && iDb<db->nDb );
124131 const char *zTab = SCHEMA_TABLE(iDb);
124132 const char *zDb = db->aDb[iDb].zDbSName;
124138 if( !OMIT_TEMPDB && iDb==1 ){
124149 if( !OMIT_TEMPDB && iDb==1 ){
124187 sqlite3BeginWriteOperation(pParse, 1, iDb);
124189 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
124192 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
124383 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
124387 db->aDb[iDb].zDbSName ) ){
124393 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
124412 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
124422 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
124423 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
124559 int iDb; /* Index of the database that is being written */
124592 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
124593 if( iDb<0 ) goto exit_create_index;
124604 iDb = 1;
124609 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
124618 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
124630 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
124632 pDb = &db->aDb[iDb];
124690 sqlite3CodeVerifySchema(pParse, iDb);
124718 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
124722 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
124780 pIndex->pSchema = db->aDb[iDb].pSchema;
124787 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
125030 sqlite3BeginWriteOperation(pParse, 1, iDb);
125039 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
125061 db->aDb[iDb].zDbSName,
125074 sqlite3ChangeCookie(pParse, iDb);
125075 sqlite3VdbeAddParseSchemaOp(v, iDb,
125198 int iDb;
125224 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
125229 const char *zDb = db->aDb[iDb].zDbSName;
125230 const char *zTab = SCHEMA_TABLE(iDb);
125234 if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
125244 sqlite3BeginWriteOperation(pParse, 1, iDb);
125247 db->aDb[iDb].zDbSName, pIndex->zName
125249 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
125250 sqlite3ChangeCookie(pParse, iDb);
125251 destroyRootPage(pParse, pIndex->tnum, iDb);
125252 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
125857 ** for database iDb. The code to actually verify the schema cookie
125861 static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){
125862 assert( iDb>=0 && iDb<pToplevel->db->nDb );
125863 assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
125864 assert( iDb<SQLITE_MAX_DB );
125865 assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
125866 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
125867 DbMaskSet(pToplevel->cookieMask, iDb);
125868 if( !OMIT_TEMPDB && iDb==1 ){
125873 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
125874 sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb);
125906 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
125908 sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb);
125909 DbMaskSet(pToplevel->writeMask, iDb);
126058 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
126059 sqlite3BeginWriteOperation(pParse, 0, iDb);
126075 int iDb; /* The database index number */
126081 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
126111 int iDb; /* The database index number */
126137 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
126138 if( iDb<0 ) return;
126141 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
126151 iDb = sqlite3SchemaToIndex(db, pIndex->pTable->pSchema);
126152 sqlite3BeginWriteOperation(pParse, 0, iDb);
127019 int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
127025 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
127171 int iDb; /* Database number */
127255 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
127256 assert( iDb<db->nDb );
127258 db->aDb[iDb].zDbSName);
127286 sqlite3BeginWriteOperation(pParse, bComplex, iDb);
127344 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
127346 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
127352 sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1);
127354 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
130977 int iDb, /* Index of database housing pTab */
131039 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
131049 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
131359 SQLITE_PRIVATE void sqlite3FkClearTriggerCache(sqlite3 *db, int iDb){
131361 Hash *pHash = &db->aDb[iDb].pSchema->tblHash;
131553 int iDb; /* Index of database containing pTab */
131564 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
131565 zDb = db->aDb[iDb].zDbSName;
131637 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
131646 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
131653 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
131664 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
131982 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
131994 pSrc->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
132169 int iDb, /* The database index in sqlite3.aDb[] */
132179 sqlite3TableLock(pParse, iDb, pTab->tnum,
132183 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
132189 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
132364 ** Return non-zero if the table pTab in database iDb or any of its indices
132366 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
132369 static int readsTable(Parse *p, int iDb, Table *pTab){
132380 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
132525 ** which is in database iDb. Return the register number for the register
132548 int iDb, /* Index of the database holding pTab */
132552 assert( pParse->db->aDb[iDb].pSchema!=0 );
132558 Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
132583 pInfo->iDb = iDb;
132627 pDb = &db->aDb[p->iDb];
132630 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
132687 Db *pDb = &db->aDb[p->iDb];
132695 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
132850 int iDb; /* Index of database holding TABLE */
132899 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
132900 assert( iDb<db->nDb );
132902 db->aDb[iDb].zDbSName) ){
132950 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
132965 && xferOptimization(pParse, pTab, pSelect, onError, iDb)
132976 regAutoinc = autoIncBegin(pParse, iDb, pTab);
133085 if( pTrigger || readsTable(pParse, iDb, pTab) ){
134796 int iDb;
134812 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
134819 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
134821 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
134832 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
137972 ** Set the safety_level and pager flags for pager iDb. Or if iDb<0
138156 int iDb; /* Database index for <database> */
138167 /* Interpret the [schema.] part of the pragma statement. iDb is the
138169 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
138170 if( iDb<0 ) return;
138171 pDb = &db->aDb[iDb];
138176 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
138286 sqlite3VdbeUsesBtree(v, iDb);
138292 aOp[0].p1 = iDb;
138293 aOp[1].p1 = iDb;
138297 sqlite3BeginWriteOperation(pParse, 0, iDb);
138298 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
138299 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
138385 sqlite3CodeVerifySchema(pParse, iDb);
138388 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
138396 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x);
138480 iDb = 0;
138484 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
138555 aOp[0].p1 = iDb;
138556 aOp[1].p1 = iDb;
138558 aOp[4].p1 = iDb;
138560 sqlite3VdbeUsesBtree(v, iDb);
138578 sqlite3BeginWriteOperation(pParse, 0, iDb);
138580 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
138602 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
138636 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
138673 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
138680 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
138858 }else if( iDb!=1 ){
139068 sqlite3CodeVerifySchema(pParse, iDb);
139280 k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
139290 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
139291 zDb = db->aDb[iDb].zDbSName;
139292 sqlite3CodeVerifySchema(pParse, iDb);
139293 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
139295 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
139302 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
139306 sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
139308 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
139423 ** then iDb is set to the index of the database identified by <db>.
139424 ** In this case, the integrity of database iDb only is verified by
139428 ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
139431 assert( iDb>=0 );
139432 assert( iDb==0 || pId2->z );
139433 if( pId2->z==0 ) iDb = -1;
139447 iDb>=0 ? db->aDb[iDb].zDbSName : 0);
139461 if( iDb>=0 && i!=iDb ) continue;
140009 sqlite3VdbeUsesBtree(v, iDb);
140020 aOp[0].p1 = iDb;
140021 aOp[1].p1 = iDb;
140041 aOp[0].p1 = iDb;
140042 aOp[1].p1 = iDb;
140077 int iBt = (pId2->z?iDb:SQLITE_MAX_DB);
140197 for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
140198 if( iDb==1 ) continue;
140199 sqlite3CodeVerifySchema(pParse, iDb);
140200 pSchema = db->aDb[iDb].pSchema;
140218 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
140224 db->aDb[iDb].zDbSName, pTab->zName);
140800 int iDb = pData->iDb;
140813 assert( iDb>=0 && iDb<db->nDb );
140830 u8 saved_iDb = db->init.iDb;
140835 db->init.iDb = iDb;
140849 db->init.iDb = saved_iDb;
140853 assert( iDb==1 );
140875 pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
140895 ** database file is given by iDb. iDb==0 is used for the main
140896 ** database. iDb==1 should never be used. iDb>=2 is used for
140900 SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
140915 assert( iDb>=0 && iDb<db->nDb );
140916 assert( db->aDb[iDb].pSchema );
140918 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
140928 azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb);
140935 initData.iDb = iDb;
140950 pDb = &db->aDb[iDb];
140952 assert( iDb==1 );
141002 if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
141063 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
141075 db->aDb[iDb].zDbSName, zSchemaTabName);
141091 sqlite3AnalysisLoad(db, iDb);
141095 assert( pDb == &(db->aDb[iDb]) );
141099 pDb = &db->aDb[iDb];
141112 DbSetProperty(db, iDb, DB_SchemaLoaded);
141131 sqlite3ResetOneSchema(db, iDb);
141202 int iDb;
141208 for(iDb=0; iDb<db->nDb; iDb++){
141210 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
141230 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
141231 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
141232 if( DbHasProperty(db, iDb, DB_SchemaLoaded) ) pParse->rc = SQLITE_SCHEMA;
141233 sqlite3ResetOneSchema(db, iDb);
141244 ** Convert a schema pointer into the iDb index that indicates
143478 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
143479 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
143772 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
143773 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
147916 int iDb; /* Schema index for this data src */
147935 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
147936 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
150175 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
150182 sqlite3CodeVerifySchema(pParse, iDb);
150183 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
150212 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1);
150679 int iDb; /* The database to store the trigger in */
150693 iDb = 1;
150697 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
150698 if( iDb<0 ){
150714 if( db->init.busy && iDb!=1 ){
150720 ** then set iDb to 1 to create the trigger in the temporary database.
150727 iDb = 1;
150733 sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
150761 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
150763 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
150768 sqlite3CodeVerifySchema(pParse, iDb);
150826 pTrigger->pSchema = db->aDb[iDb].pSchema;
150855 if( db->init.iDb==1 ){
150884 int iDb; /* Database containing the trigger */
150890 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
150897 sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
150939 sqlite3BeginWriteOperation(pParse, 0, iDb);
150945 db->aDb[iDb].zDbSName, zName,
150948 sqlite3ChangeCookie(pParse, iDb);
150949 sqlite3VdbeAddParseSchemaOp(v, iDb,
150955 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
150956 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
151235 int iDb;
151237 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
151238 assert( iDb>=0 && iDb<db->nDb );
151240 assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
151244 const char *zDb = db->aDb[iDb].zDbSName;
151245 const char *zTab = SCHEMA_TABLE(iDb);
151246 if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
151259 db->aDb[iDb].zDbSName, pTrigger->zName
151261 sqlite3ChangeCookie(pParse, iDb);
151262 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
151269 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
151273 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
151274 pHash = &(db->aDb[iDb].pSchema->trigHash);
152373 int iDb; /* Database containing the table being updated */
152417 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
152569 db->aDb[iDb].zDbSName);
152657 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
153847 int iDb = 0;
153854 iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
153855 if( iDb<0 ) goto build_vacuum_end;
153862 iDb = sqlite3FindDb(pParse->db, pNm);
153863 if( iDb<0 ) iDb = 0;
153866 if( iDb!=1 ){
153872 sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
153873 sqlite3VdbeUsesBtree(v, iDb);
153886 int iDb, /* Which attached DB to vacuum */
153941 zDbMain = db->aDb[iDb].zDbSName;
153942 pMain = db->aDb[iDb].pBt;
153980 pgflags = db->aDb[iDb].safety_level | (db->flags & PAGER_FLAGS_MASK);
153984 sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size);
154021 db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */
154035 db->init.iDb = 0;
154123 db->init.iDb = 0;
154577 int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
154578 assert( iDb>=0 ); /* The database the table is being created in */
154580 pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
154622 int iDb;
154642 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
154647 db->aDb[iDb].zDbSName,
154654 sqlite3ChangeCookie(pParse, iDb);
154658 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
154663 sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
154726 int iDb;
154757 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
154758 pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
154917 ** of the virtual table named zTab in database iDb.
154923 SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
154929 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
155053 ** of the virtual table named zTab in database iDb. This occurs
155058 SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
155062 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
167250 int iDb; /* Index of database containing table/index */
167255 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
167278 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
167309 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
167353 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
167382 if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
167674 int iDb = sqlite3SchemaToIndex(db, pIx->pSchema);
167675 sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb);
179463 int iDb, nDb;
179473 nDb = iDb = sqlite3FindDbName(db, zSchema);
179474 if( iDb<0 ) nDb--;
179476 iDb = 0;
179479 for(; iDb<=nDb; iDb++){
179480 Btree *pBt = db->aDb[iDb].pBt;
180660 int iDb; /* Schema to checkpoint */
180682 iDb = sqlite3FindDbName(db, zDb);
180684 iDb = SQLITE_MAX_DB; /* This means process all schemas */
180686 if( iDb<0 ){
180691 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
180721 ** Run a checkpoint on database iDb. This is a no-op if database iDb is
180733 ** If iDb is passed SQLITE_MAX_DB then all attached databases are
180740 SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
180748 testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */
180749 testcase( iDb==SQLITE_MAX_DB );
180752 if( i==iDb || iDb==SQLITE_MAX_DB ){
182660 int iDb;
182662 iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
182663 if( iDb>=0 ){
182664 db->init.iDb = iDb;
183012 int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0;
183013 return iDb<0 ? 0 : db->aDb[iDb].pBt;
183087 int iDb = sqlite3FindDbName(db, zDb);
183088 if( iDb==0 || iDb>1 ){
183089 Btree *pBt = db->aDb[iDb].pBt;
183122 int iDb;
183123 iDb = sqlite3FindDbName(db, zDb);
183124 if( iDb==0 || iDb>1 ){
183125 Btree *pBt = db->aDb[iDb].pBt;
183166 int iDb;
183175 iDb = sqlite3FindDbName(db, zDb);
183176 if( iDb==0 || iDb>1 ){
183177 Btree *pBt = db->aDb[iDb].pBt;
221819 int iDb; /* Schema used for this query */
221842 int iDb; /* Index of database to analyze */
221861 int iDb;
221867 iDb = sqlite3FindDb(db, &nm);
221868 if( iDb<0 ){
221873 iDb = 0;
221886 pTab->iDb = iDb;
221995 pCsr->iDb = pTab->iDb;
222208 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
222271 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
222451 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
222452 if( pCsr->iDb<0 ){
222453 pCsr->iDb = 0;
222458 pCsr->iDb = pTab->iDb;
222477 pTab->db->aDb[pCsr->iDb].zDbSName);
222548 int iDb = pCsr->iDb;
222549 sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC);
222651 int iDb; /* Index of database to analyze */
222847 pCsr->iDb = sqlite3FindDbName(db, zSchema);
222848 if( pCsr->iDb<0 ) return SQLITE_OK;
222850 pCsr->iDb = 0;
222852 pBt = db->aDb[pCsr->iDb].pBt;
222904 sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
222929 int iDb;
222951 iDb = ALWAYS(zSchema) ? sqlite3FindDbName(pTab->db, zSchema) : -1;
222952 if( NEVER(iDb<0) ){
222956 pBt = pTab->db->aDb[iDb].pBt;
Indexes created Wed Mar 04 05:31:52 UTC 2026