Lines Matching defs:affinity
4159 ** numeric affinity to the value. This means that an attempt is
9462 char affinity; /* One of the SQLITE_AFF_... values */
9513 ** Column affinity types.
9520 ** when multiple affinity types are concatenated into a string and
9536 ** affinity value.
9541 ** Additional bit values that can be ORed with an affinity without
9542 ** changing the affinity.
9641 char *zColAff; /* String defining the affinity of each column */
9840 char *zColAff; /* String defining the affinity of each column */
9999 char affinity; /* The affinity of the column or 0 if not a column */
10393 char affinity; /* MakeRecord with this affinity for SRT_Set */
10448 u8 affinity; /* Affinity used when eDest==SRT_Set */
21700 /* 29 */ "Affinity",
57164 u8 affinity, /* Affinity to use */
57211 if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
57214 sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
57222 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
57232 sqlite3ValueApplyAffinity(pVal, affinity, enc);
60478 ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*
62263 ** Processing is determine by the affinity parameter:
62271 ** always preferred, even if the affinity is REAL, because
62281 Mem *pRec, /* The value to apply affinity to */
62282 char affinity, /* The affinity to be applied */
62285 if( affinity==SQLITE_AFF_TEXT ){
62294 }else if( affinity!=SQLITE_AFF_NONE ){
62295 assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
62296 || affinity==SQLITE_AFF_NUMERIC );
62325 u8 affinity,
62328 applyAffinity((Mem *)pVal, affinity, enc);
62705 char affinity; /* Affinity to use for comparison */
62751 const char *zAffinity; /* The affinity to be applied */
62752 char cAff; /* A single character of affinity */
62766 char *zAffinity; /* The affinity string for the record */
64071 ** has REAL affinity. Such column values may still be stored as
64194 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
64196 ** to coerce both inputs according to this affinity before the
64198 ** affinity is used. Note that the affinity conversions are stored
64265 char affinity; /* Affinity to use for comparison */
64299 u.ai.affinity = pOp->p5 & SQLITE_AFF_MASK;
64300 if( u.ai.affinity ){
64301 applyAffinity(pIn1, u.ai.affinity, encoding);
64302 applyAffinity(pIn3, u.ai.affinity, encoding);
64883 /* Opcode: Affinity P1 P2 * P4 *
64888 ** string indicates the column affinity that should be used for the nth
64893 const char *zAffinity; /* The affinity to be applied */
64894 char cAff; /* A single character of affinity */
64918 ** string indicates the column affinity that should be used for the nth
64921 ** The mapping from character to affinity is given by the SQLITE_AFF_
64924 ** If P4 is NULL then all index fields have the affinity NONE.
64939 char *zAffinity; /* The affinity string for the record */
69971 pExpr->affinity = SQLITE_AFF_INTEGER;
69995 pExpr->affinity = SQLITE_AFF_INTEGER;
70185 pExpr->affinity = SQLITE_AFF_INTEGER;
70283 /* FIX ME: Compute pExpr->affinity based on the expected return
70934 ** Return the 'affinity' of the expression pExpr if any.
70938 ** affinity of that column is returned. Otherwise, 0x00 is returned,
70939 ** indicating no affinity for the expression.
70942 ** have an affinity:
70969 return pExpr->pTab->aCol[j].affinity;
70971 return pExpr->affinity;
71044 ** type affinity of the other operand. This routine returns the
71045 ** type affinity that should be used for the comparison operator.
71051 ** affinity, use that. Otherwise use no affinity.
71064 /* One side is a column, the other is not. Use the columns affinity. */
71071 ** pExpr is a comparison operator. Return the type affinity that should
71093 ** idx_affinity is the affinity of an indexed column. Return true
71094 ** if the index with affinity idx_affinity may be used to implement
72198 ** unchanged by OP_Affinity with the affinity given in the second
72394 /* Check that the affinity that will be used to perform the
72395 ** comparison is the same as the affinity of the column. If
72399 int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
72528 char affinity; /* Affinity of the LHS of the IN */
72537 affinity = sqlite3ExprAffinity(pLeft);
72545 ** statement returns a column value, then the affinity of that
72547 ** SELECT... statement are columns, then numeric affinity is used
72548 ** if either column has NUMERIC or INTEGER affinity. If neither
72549 affinity
72569 dest.affinity = (u8)affinity;
72585 ** that columns affinity when building index keys. If <expr> is not
72586 ** a column, use numeric affinity.
72593 if( !affinity ){
72594 affinity = SQLITE_AFF_NONE;
72626 sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
72716 char affinity; /* Comparison affinity to use */
72729 /* Figure out the affinity to use to create a key from the results
72733 affinity = comparisonAffinity(pExpr);
72763 sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
73110 ** Record the fact that an affinity change has occurred on iCount
73642 /* If the column has REAL affinity, it may currently be stored as an
73645 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
73743 assert( pExpr->affinity==OE_Rollback
73744 || pExpr->affinity==OE_Abort
73745 || pExpr->affinity==OE_Fail
73746 || pExpr->affinity==OE_Ignore
73753 if( pExpr->affinity==OE_Abort ){
73757 if( pExpr->affinity==OE_Ignore ){
73761 sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
78000 /* If there is no type specified, columns have the default affinity
78002 ** be called next to set pCol->affinity correctly.
78004 pCol->affinity = SQLITE_AFF_NONE;
78023 ** associated affinity type.
78027 ** found, the corresponding affinity is returned. If zType contains
78032 ** Substring | Affinity
78100 pCol->affinity = sqlite3AffinityType(pCol->zType);
78436 assert( pCol->affinity-SQLITE_AFF_TEXT >= 0 );
78437 assert( pCol->affinity-SQLITE_AFF_TEXT < ArraySize(azType) );
78438 testcase( pCol->affinity==SQLITE_AFF_TEXT );
78439 testcase( pCol->affinity==SQLITE_AFF_NONE );
78440 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
78441 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
78442 testcase( pCol->affinity==SQLITE_AFF_REAL );
78444 zType = azType[pCol->affinity - SQLITE_AFF_TEXT];
78446 assert( pCol->affinity==SQLITE_AFF_NONE
78447 || pCol->affinity==sqlite3AffinityType(zType) );
83852 ** apply the affinity of the parent key). If this fails, then there
83855 ** will have INTEGER affinity applied to it, which may not be correct. */
83985 ** the parent key columns. The affinity of the parent key column should
83997 /* Set the collation sequence and affinity of the LHS of each TK_EQ
84005 pLeft->affinity = pCol->affinity;
84009 pLeft->affinity = SQLITE_AFF_INTEGER;
84032 pLeft->affinity = SQLITE_AFF_INTEGER;
84487 ** that the affinity and collation sequence associated with the
84551 pRaise->affinity = OE_Abort;
84728 ** Return a pointer to the column affinity string associated with index
84729 ** pIdx. A column affinity string has one character for each column in
84730 ** the table, according to the affinity of the column:
84732 ** Character Column affinity
84743 ** Memory for the buffer containing the column index affinity string
84749 /* The first time a column affinity string for a particular index is
84753 ** The column affinity string will eventually be deleted by
84766 pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
84776 ** Set P4 of the most recently inserted opcode to a column affinity
84777 ** string for table pTab. A column affinity string has one character
84778 ** for each column indexed by the index, according to the affinity of the
84781 ** Character Column affinity
84790 /* The first time a column affinity string for a particular table
84794 ** The column affinity string will eventually be deleted by
84809 zColAff[i] = pTab->aCol[i].affinity;
86401 if( pDest->aCol[i].affinity!=pSrc->aCol[i].affinity ){
86402 return 0; /* Affinity must be the same on all columns */
90169 pDest->affinity = 0;
90776 p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
90785 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, 1, r1, &p->affinity, 1);
91041 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid, &p->affinity, 1);
91464 pCol->affinity = sqlite3ExprAffinity(p);
91465 if( pCol->affinity==0 ) pCol->affinity = SQLITE_AFF_NONE;
92091 p->affinity =
92092 sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affinity);
92094 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iMem, 1, r1, &p->affinity, 1);
93799 ** Apply the affinity pDest->affinity before storing
95975 pCol->affinity, &pValue);
95980 if( iReg>=0 && pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
98452 idxaff = pIdx->pTable->aCol[iColumn].affinity;
98528 ** be the name of an indexed column with TEXT affinity. */
99581 aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
100229 ** an sqlite3_value structure containing the same value, with affinity
100237 ** affinity aff applied to it, instead.
100323 u8 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
100407 u8 aff; /* Column affinity */
100412 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
100464 u8 aff; /* Column affinity */
100475 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
101075 ** Code an OP_Affinity opcode to apply the column affinity string zAff
101094 ** and end of the affinity string.
101194 ** compute the affinity string.
101204 ** copy of the column affinity string of the index allocated using
101206 ** with equality constraints that use NONE affinity are set to
101212 ** In the example above, the index on t1(a) has TEXT affinity. But since
101213 ** the right hand side of the equality constraint (t2.b) has NONE affinity,
101215 ** a key to search the index. Hence the first byte in the returned affinity
101224 char **pzAff /* OUT: Set to point to affinity string */
101234 char *zAff; /* Affinity string to return */
101707 char *zStartAff; /* Affinity for start of range constraint */
101708 char *zEndAff; /* Affinity for end of range constraint */
101781 ** applied to the operands, set the affinity to apply to pRight to
101822 ** applied to the operands, set the affinity to apply to pRight to
105897 yygotominor.yy118.pExpr->affinity = OE_Ignore;
105907 yygotominor.yy118.pExpr->affinity = (char)yymsp[-3].minor.yy4;
110560 * Type affinity versus type storage.
110563 * affinity system. The system provides for automated coercion of
