Lines Matching defs:target
361 ** compiler that the target identifier should have external linkage.
2380 ** target platform, and SQLite version.
9076 ** on the SQLite version, the target platform, and how SQLite was compiled.
12021 ** tests that the target database contains a compatible table. A table is
12063 ** For each DELETE change, the function checks if the target database
12067 ** the changeset the row is deleted from the target database.
12108 ** For each UPDATE change, the function checks if the target database
12112 ** stored in the changeset the row is updated within the target database.
12141 ** write to the target database) occurs, then the savepoint transaction is
12142 ** rolled back, restoring the target database to its original state, and an
14701 ** When SQLITE_OMIT_WSD is defined, it means that the target platform does
14909 ** SQLITE_OS_UNIX or SQLITE_OS_WIN depending on the target platform.
16203 #define OPFLG_JUMP 0x01 /* jump: P2 holds jmp target */
18646 ** represents the target tables for DELETE, INSERT, and UPDATE statements.
18775 ** conflict-target clause. (In "ON CONFLICT(a,b)" the "(a,b)" is the
18776 ** conflict-target clause.) The pUpsertTargetWhere is the optional
18785 ExprList *pUpsertTarget; /* Optional description of conflict target */
23154 ** state vector. If writable static data is unsupported on the target,
25354 ** structure. If writable static data is unsupported on the target,
25494 ** on the target platform. Or, this symbol
32687 ** state vector. If writable static data is unsupported on the target,
45158 ** target system. GetVersionEx was first deprecated in Win8.1.
45170 ** target system. It is unavailable when using "mincore.lib" on Win10.
75783 ** total number of pages that participate, including the target page and
83593 ** so that the jump target is relative to the first operation inserted.
95197 ** to. Call this SeekGE.P3/P4 row the "target".
95203 ** might be the target row, or it might be near and slightly before the
95204 ** target row, or it might be after the target row. If the cursor is
95205 ** currently before the target row, then this opcode attempts to position
95206 ** the cursor on or after the target row by invoking sqlite3BtreeStep()
95210 ** cursor ends up pointing at a valid row that is past the target
95225 ** <li> If the cursor is left pointing to a row that is before the target
95229 ** <li> If the cursor is left pointing at the target row, either because it
95230 ** was at the target row to begin with or because one or more
95231 ** sqlite3BtreeNext() calls moved the cursor to the target row,
95234 ** <li> If the cursor started out before the target row and a call to
95236 ** (indicating that the target row definitely does not exist in the
95239 ** <li> If the cursor ends up on a valid row that is past the target row
95240 ** (indicating that the target row does not exist in the btree) then
109742 int target /* Store function result in this register */
109759 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
109761 sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
109763 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
109774 return sqlite3ExprCodeTarget(pParse, &caseExpr, target);
109780 sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target);
109782 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
109792 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
109806 target);
109815 target);
109827 target);
109829 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
109843 sqlite3VdbeLoadString(v, target,
109849 return target;
109861 int target /* Where to store the result of the expression */
109880 sqlite3VdbeAddOp3(v, OP_IfNullRow, p->iIdxCur, addr+3, target);
109882 sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);
109887 sqlite3ExprCode(pParse, pExpr, target);
109891 sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);
109894 return target;
109902 ** expression. Attempt to store the results in register "target".
109906 ** be stored in target. The result might be stored in some other
109911 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
109914 int inReg = target; /* Results stored in register inReg */
109921 assert( target>0 && target<=pParse->nMem );
109929 && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0
109949 pCol->iSorterColumn, target);
109956 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
109959 return target;
109975 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
110027 sqlite3VdbeAddOp2(v, OP_SCopy, iSrc, target);
110028 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
110029 return target;
110042 pExpr->iColumn, iTab, target,
110047 codeInteger(pParse, pExpr, 0, target);
110048 return target;
110051 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
110052 return target;
110057 codeReal(v, pExpr->u.zToken, 0, target);
110058 return target;
110063 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
110064 return target;
110072 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
110073 return target;
110087 sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
110088 return target;
110095 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
110102 return target;
110110 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
110111 if( inReg!=target ){
110112 sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
110113 inReg = target;
110116 sqlite3VdbeAddOp2(v, OP_Cast, target,
110134 codeVectorCompare(pParse, pExpr, target, op, p5);
110183 sqlite3VdbeAddOp3(v, op, r2, r1, target);
110192 codeInteger(pParse, pLeft, 1, target);
110193 return target;
110197 codeReal(v, pLeft->u.zToken, 1, target);
110198 return target;
110207 sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
110238 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
110244 sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
110303 SQLITE_PTR_TO_INT(pDef->pUserData), target);
110372 sqlite3VdbeAddFunctionCall(pParse, constMask, r1, target, nFarg,
110381 return target;
110419 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
110421 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
110423 sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
110425 return target;
110442 exprCodeBetween(pParse, pExpr, target, 0, 0);
110443 return target;
110450 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
110451 if( inReg!=target ){
110452 sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
110453 inReg = target;
110509 sqlite3VdbeAddOp2(v, OP_Param, p1, target);
110510 VdbeComment((v, "r[%d]=%s.%s", target,
110522 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
110552 target);
110553 inReg = target;
110563 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
110640 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
110645 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
110647 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
110790 ** results in register target. The results are guaranteed to appear
110791 ** in register target.
110793 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
110797 assert( target>0 && target<=pParse->nMem );
110800 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
110801 if( inReg!=target ){
110808 sqlite3VdbeAddOp2(pParse->pVdbe, op, inReg, target);
110817 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
110820 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
110826 ** results in register target. The results are guaranteed to appear
110827 ** in register target. If the expression is constant, then this routine
110830 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
110832 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
110834 sqlite3ExprCodeCopy(pParse, pExpr, target);
110840 ** expression list into a sequence of registers beginning at target.
110861 int target, /* Where to write results */
110870 assert( target>0 );
110887 sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
110892 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
110894 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
110895 if( inReg!=target+i ){
110900 && pOp->p2+pOp->p3+1==target+i
110905 sqlite3VdbeAddOp2(v, copyOp, inReg, target+i);
130512 /* There is just on ON CONFLICT clause and it has no constraint-target */
130515 /* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
130635 /* The first ON CONFLICT clause has a conflict target other than
133378 ** state vector. If writable static data is unsupported on the target,
141976 ** target slot in the parent is the right operand of a LEFT JOIN, or one of
144977 ** In this case, it is an error if the target object (pSrc->a[0]) name
144988 "target object/alias may not appear in FROM clause: %s",
146811 ** holds both the TriggerStep object and the TriggerStep.target.z string.
146818 Token *pName, /* The target name */
147208 ** This routine adds a specific database name, if needed, to the target when
147210 ** referring to a target in another database. An exception is when the
147216 TriggerStep *pStep /* The trigger containing the target token */
149249 Expr *pTargetWhere, /* Optional WHERE clause on the target */
149276 ** symbols in the conflict-target.
149290 ExprList *pTarget; /* The conflict-target clause */
149291 Expr *pTerm; /* One term of the conflict-target clause */
149301 /* Resolve all symbolic names in the conflict-target clause, which
149315 /* Check to see if the conflict target matches the rowid. */
149324 /* The conflict-target is the rowid of the primary table */
149333 ** prior to comparing against the conflict-target expression.
149373 break; /* Column ii of the index matches column jj of target */
149377 /* The target contains no match for column jj of the index */
149382 /* Column ii of the index did not match any term of the conflict target.
149406 ** conflict target, or if pUpsert is followed by another ON CONFLICT
154037 ** Following the above, code to terminate the loop. Label A, the target
157418 ** rows of the target table (pSrc) that can be used. */
187334 ** of each column in the target fts3 table, in order from left to right.
208190 ** sqlite3rbu.h. Essentially, for each table xyz in the target database
208193 ** update, insert or delete from the target table.
208205 ** directly to the target tables. Instead it creates "imposter"
208241 ** If some client does modify the target database mid RBU update, or some
208327 ** * UPDATE and DELETE statements must identify their target rows by
208347 ** target database to be updated, the RBU database should contain a table
208348 ** named "data_<target name>" containing the same set of columns as the
208349 ** target table, and one more - "rbu_control". The data_% table should
208351 ** the same type as the corresponding column in the target database.
208353 ** the target database contains:
208364 ** tables or view named using the data_<target> naming scheme.
208366 ** Instead of the plain data_<target> naming scheme, RBU database tables
208367 ** may also be named data<integer>_<target>, where <integer> is any sequence
208375 ** If the target database table is a virtual table or a table that has no
208380 ** example, if the target db contains either of the following:
208390 ** target table must be present in the input table. For virtual tables,
208402 ** For each row to INSERT into the target database as part of the RBU
208408 ** If the target database table has an INTEGER PRIMARY KEY, it is not
208412 ** For each row to DELETE from the target database as part of the RBU
208419 ** For each row to UPDATE from the target database as part of the RBU
208426 ** there are columns in the target database table, and must consist entirely
208441 ** target table with the value stored in the corresponding data_% column, the
208443 ** the target table column. rbu_delta() is invoked with two arguments - the
208444 ** original value currently stored in the target table column and the
208459 ** the existing value within the target database table must be of type BLOB.
208463 ** If the target database table is a virtual table or a table with no PRIMARY
208477 ** the PRIMARY KEY of the corresponding target database table. In other
208484 ** stored on disk to an existing target database. Essentially, the
208500 ** apply the update to the target database, then the RBU database
208507 ** If an update is only partially applied to the target database by the
208521 ** While an RBU handle is open, a SHARED lock may be held on the target
208544 ** Argument zTarget is the path to the target database. Argument zRbu is
208593 ** handle specifying the same target and state databases.
208597 ** is the name of the target database file. In this case, on UNIX, if the
208599 ** with the same permissions as the target db is made.
208646 ** connection to access the target and rbu update databases. This
208650 ** handle. The second argument should be passed zero to access the target
208655 ** * If any target tables are virtual tables, it may be necessary to
208656 ** call sqlite3_create_module() on the target database handle to
208666 ** rbu_delta() implementation with the target database handle.
208678 ** Do some work towards applying the RBU update to the target db.
208725 ** updates) that have been performed on the target database since the
208792 ** the target database file.
208943 ** Only valid if STAGE==1. The target database name of the table
208947 ** Only valid if STAGE==1. The target database name of the index
208968 ** target db file.
209053 ** the target database that require updating. For each such table, the
209076 char **azTblCol; /* Array of unquoted target column names */
209077 char **azTblType; /* Array of target column types */
209078 int *aiSrcOrder; /* src table col -> target table col */
209079 u8 *abTblPk; /* Array of flags, set on target PK columns */
209086 const char *zTbl; /* Name of target db table */
209088 const char *zIdx; /* Name of target db index (or null) */
209165 ** corresponding target database table.
209171 ** for an UPDATE operation does not exist in the target table, then
209189 sqlite3 *dbMain; /* target database handle */
209191 char *zTarget; /* Path to target db */
209201 rbu_file *pTargetFd; /* File handle open on target db */
209255 sqlite3rbu *pRbu; /* Pointer to rbu object (rbu target only) */
209795 "SELECT rbu_target_name(name, type='view') AS target, name "
209797 "WHERE type IN ('table', 'view') AND target IS NOT NULL "
210295 ** a WITHOUT ROWID table. It queries the target database to find the
210296 ** largest key that has already been written to the target table and
210358 ** queries the target index b-tree for the largest key already written to
210839 ** used to access that PK index. For example, if the target table is
210918 ** same schema as the actual target table (less any UNIQUE constraints).
210941 /* If the target table column is an "INTEGER PRIMARY KEY", add
210975 ** the target table, plus one (for the rbu_control column), plus one more
210976 ** (for the rbu_rowid column) if the target table is an implicit IPK or
211124 ** target database object currently indicated by the iterator passed
211263 /* Create the INSERT statement to write to the target PK b-tree */
211273 /* Create the DELETE statement to write to the target PK b-tree.
211579 ** open on the target database. Use this handle instead of opening a new
211730 /* Mark the database file just opened as an RBU target database. If
211778 ** Return the current wal-index header checksum for the target database
211884 ** directory in which the target database and the wal file reside, in
212031 ** holding a SHARED lock on the target database file (because it is
212407 ** RBU vacuum operation, create the schema in the target db.
212468 ** when this handle was opened, create the target database schema. */
212636 ** target database in the file-system, delete it. If an error occurs,
212652 ** specified a URI with a vfs=? option in place of a target database
212684 ** name of a table expected to appear in the target database. It returns
212735 ** indexes on the corresponding target database table.
212797 /* Open the target, RBU and state databases */
213045 ** specifying the current target and state databases to start a new
213078 ** updates) that have been performed on the target database since the
213251 ** object can be marked as the target database of an RBU update. This
213255 ** associated with an RBU target database currently in RBU_STAGE_OAL
213260 ** target database may not be in wal mode already.
213266 ** the RBU target in RBU_STAGE_OAL stage, instead of opening the *-wal
213269 ** 3b. The *-shm pages returned by xShmMap() for a target db file in
213272 ** are no-ops on target database files in RBU_STAGE_OAL mode. This is
213276 ** 3c. If an EXCLUSIVE lock is attempted on a target database file in any
213283 ** all xWrite() calls on the target database file perform no IO.
213286 ** xShmLock() WRITER, CHECKPOINTER and READ0 locks on the target
213289 ** relinquished). Finally, calls to xSync() on the target database
213467 /* If this is being called to read the first page of the target
213584 /* If this is an RBU vacuum operation and this is the target database,
213725 /* Prevent SQLite from taking a shm-lock on the target file when it
213952 /* If this call is to check if a *-wal file associated with an RBU target
217272 /* Locate and if necessary initialize the target table object */