Lines Matching refs:affinity
3801 ** numeric affinity to the value. This means that an attempt is
8557 char affinity; /* One of the SQLITE_AFF_... values */
8608 ** Column affinity types.
8615 ** when multiple affinity types are concatenated into a string and
8631 ** affinity value.
8636 ** Additional bit values that can be ORed with an affinity without
8637 ** changing the affinity.
8736 char *zColAff; /* String defining the affinity of each column */
8934 char *zColAff; /* String defining the affinity of each column */
9093 char affinity; /* The affinity of the column or 0 if not a column */
9478 char affinity; /* MakeRecord with this affinity for SRT_Set */
9532 u8 affinity; /* Affinity used when eDest==SRT_Set */
47036 u8 affinity, /* Affinity to use */
47063 if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
47066 sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
47072 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
50221 ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*
51884 ** Processing is determine by the affinity parameter:
51892 ** always preferred, even if the affinity is REAL, because
51902 Mem *pRec, /* The value to apply affinity to */
51903 char affinity, /* The affinity to be applied */
51906 if( affinity==SQLITE_AFF_TEXT ){
51915 }else if( affinity!=SQLITE_AFF_NONE ){
51916 assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
51917 || affinity==SQLITE_AFF_NUMERIC );
51946 u8 affinity,
51949 applyAffinity((Mem *)pVal, affinity, enc);
52329 char affinity; /* Affinity to use for comparison */
52373 const char *zAffinity; /* The affinity to be applied */
52374 char cAff; /* A single character of affinity */
52388 char *zAffinity; /* The affinity string for the record */
53667 ** has REAL affinity. Such column values may still be stored as
53789 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
53791 ** to coerce both inputs according to this affinity before the
53793 ** affinity is used. Note that the affinity conversions are stored
53860 char affinity; /* Affinity to use for comparison */
53890 u.ai.affinity = pOp->p5 & SQLITE_AFF_MASK;
53891 if( u.ai.affinity ){
53892 applyAffinity(pIn1, u.ai.affinity, encoding);
53893 applyAffinity(pIn3, u.ai.affinity, encoding);
54466 ** string indicates the column affinity that should be used for the nth
54471 const char *zAffinity; /* The affinity to be applied */
54472 char cAff; /* A single character of affinity */
54498 ** string indicates the column affinity that should be used for the nth
54501 ** The mapping from character to affinity is given by the SQLITE_AFF_
54504 ** If P4 is NULL then all index fields have the affinity NONE.
54519 char *zAffinity; /* The affinity string for the record */
59300 pExpr->affinity = SQLITE_AFF_INTEGER;
59324 pExpr->affinity = SQLITE_AFF_INTEGER;
59511 pExpr->affinity = SQLITE_AFF_INTEGER;
59609 /* FIX ME: Compute pExpr->affinity based on the expected return
60255 ** Return the 'affinity' of the expression pExpr if any.
60259 ** affinity of that column is returned. Otherwise, 0x00 is returned,
60260 ** indicating no affinity for the expression.
60263 ** have an affinity:
60290 return pExpr->pTab->aCol[j].affinity;
60292 return pExpr->affinity;
60358 ** type affinity of the other operand. This routine returns the
60359 ** type affinity that should be used for the comparison operator.
60365 ** affinity, use that. Otherwise use no affinity.
60378 /* One side is a column, the other is not. Use the columns affinity. */
60385 ** pExpr is a comparison operator. Return the type affinity that should
60407 ** idx_affinity is the affinity of an indexed column. Return true
60408 ** if the index with affinity idx_affinity may be used to implement
61515 ** unchanged by OP_Affinity with the affinity given in the second
61711 /* Check that the affinity that will be used to perform the
61712 ** comparison is the same as the affinity of the column. If
61716 int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
61829 char affinity;
61838 affinity = sqlite3ExprAffinity(pLeft);
61846 ** statement returns a column value, then the affinity of that
61848 ** SELECT... statement are columns, then numeric affinity is used
61849 ** if either column has NUMERIC or INTEGER affinity. If neither
61850 ** 'x' nor the SELECT... statement are columns, then numeric affinity
61869 dest.affinity = (u8)affinity;
61884 ** that columns affinity when building index keys. If <expr> is not
61885 ** a column, use numeric affinity.
61892 if( !affinity ){
61893 affinity = SQLITE_AFF_NONE;
61925 sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
62014 char affinity; /* Comparison affinity to use */
62027 /* Figure out the affinity to use to create a key from the results
62031 affinity = comparisonAffinity(pExpr);
62049 sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
62374 ** Record the fact that an affinity change has occurred on iCount
62983 /* If the column has REAL affinity, it may currently be stored as an
62986 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
63078 assert( pExpr->affinity==OE_Rollback
63079 || pExpr->affinity==OE_Abort
63080 || pExpr->affinity==OE_Fail
63081 || pExpr->affinity==OE_Ignore
63088 if( pExpr->affinity==OE_Abort ){
63092 if( pExpr->affinity==OE_Ignore ){
63096 sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
67177 /* If there is no type specified, columns have the default affinity
67179 ** be called next to set pCol->affinity correctly.
67181 pCol->affinity = SQLITE_AFF_NONE;
67200 ** associated affinity type.
67204 ** found, the corresponding affinity is returned. If zType contains
67277 pCol->affinity = sqlite3AffinityType(pCol->zType);
67612 assert( pCol->affinity-SQLITE_AFF_TEXT >= 0 );
67613 assert( pCol->affinity-SQLITE_AFF_TEXT < sizeof(azType)/sizeof(azType[0]) );
67614 testcase( pCol->affinity==SQLITE_AFF_TEXT );
67615 testcase( pCol->affinity==SQLITE_AFF_NONE );
67616 testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
67617 testcase( pCol->affinity==SQLITE_AFF_INTEGER );
67618 testcase( pCol->affinity==SQLITE_AFF_REAL );
67620 zType = azType[pCol->affinity - SQLITE_AFF_TEXT];
67622 assert( pCol->affinity==SQLITE_AFF_NONE
67623 || pCol->affinity==sqlite3AffinityType(zType) );
72885 ** apply the affinity of the parent key). If this fails, then there
72888 ** will have INTEGER affinity applied to it, which may not be correct. */
73018 ** the parent key columns. The affinity of the parent key column should
73030 /* Set the collation sequence and affinity of the LHS of each TK_EQ
73037 pLeft->affinity = pCol->affinity;
73041 pLeft->affinity = SQLITE_AFF_INTEGER;
73064 pLeft->affinity = SQLITE_AFF_INTEGER;
73521 ** that the affinity and collation sequence associated with the
73585 pRaise->affinity = OE_Abort;
73763 ** Return a pointer to the column affinity string associated with index
73764 ** pIdx. A column affinity string has one character for each column in
73765 ** the table, according to the affinity of the column:
73767 ** Character Column affinity
73778 ** Memory for the buffer containing the column index affinity string
73784 /* The first time a column affinity string for a particular index is
73788 ** The column affinity string will eventually be deleted by
73801 pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
73811 ** Set P4 of the most recently inserted opcode to a column affinity
73812 ** string for table pTab. A column affinity string has one character
73813 ** for each column indexed by the index, according to the affinity of the
73816 ** Character Column affinity
73825 /* The first time a column affinity string for a particular table
73829 ** The column affinity string will eventually be deleted by
73844 zColAff[i] = pTab->aCol[i].affinity;
75421 if( pDest->aCol[i].affinity!=pSrc->aCol[i].affinity ){
79029 pDest->affinity = 0;
79638 p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
79647 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, 1, r1, &p->affinity, 1);
79817 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid, &p->affinity, 1);
80260 pCol->affinity = sqlite3ExprAffinity(p);
80261 if( pCol->affinity==0 ) pCol->affinity = SQLITE_AFF_NONE;
80862 p->affinity =
80863 sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affinity);
80865 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iMem, 1, r1, &p->affinity, 1);
82515 ** Apply the affinity pDest->affinity before storing
84634 pCol->affinity, &pValue);
84639 if( iReg>=0 && pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
87080 idxaff = pIdx->pTable->aCol[iColumn].affinity;
87157 ** be the name of an indexed column with TEXT affinity. */
88537 ** an sqlite3_value structure containing the same value, with affinity
88545 ** affinity aff applied to it, instead.
88630 u8 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
89100 ** Code an OP_Affinity opcode to apply the column affinity string zAff
89119 ** and end of the affinity string.
89219 ** compute the affinity string.
89229 ** copy of the column affinity string of the index allocated using
89231 ** with equality constraints that use NONE affinity are set to
89237 ** In the example above, the index on t1(a) has TEXT affinity. But since
89238 ** the right hand side of the equality constraint (t2.b) has NONE affinity,
89240 ** a key to search the index. Hence the first byte in the returned affinity
89249 char **pzAff /* OUT: Set to point to affinity string */
89637 ** applied to the operands, set the affinity to apply to pRight to
89675 ** applied to the operands, set the affinity to apply to pRight to
93653 yygotominor.yy346.pExpr->affinity = OE_Ignore;
93663 yygotominor.yy346.pExpr->affinity = (char)yymsp[-3].minor.yy328;