SQLite

#if 0
  const char *zOp = 
    eOp==SQLITE_WHEREINFO_TABLE ? "TABLE" :
    eOp==SQLITE_WHEREINFO_EQUALS ? "EQUALS" :
    eOp==SQLITE_WHEREINFO_RANGE ? "RANGE" :
    eOp==SQLITE_WHEREINFO_ORDERBY ? "ORDERBY" :



    "!error!";
  printf("op=%s zVal=%s iVal=%d mask=%llx\n", zOp, zVal, iVal, mask);
#endif

  if( p->rc==SQLITE_OK ){
    assert( eOp==SQLITE_WHEREINFO_TABLE || p->pScan!=0 );
    switch( eOp ){

        zFmt = "CREATE INDEX %s_idx_%08x ON %s(%s)";
      }
      zIdx = sqlite3_mprintf(zFmt, pScan->zTable, h, pScan->zTable, zCols);
      if( !zIdx ){
        rc = SQLITE_NOMEM;
      }else{
        rc = sqlite3_exec(dbm, zIdx, 0, 0, pCtx->pzErrmsg);
#if 0
        printf("CANDIDATE: %s\n", zIdx);
#endif
      }
    }
    if( rc==SQLITE_OK && pCtx->iIdxRowid==0 ){
      int rc2;
      sqlite3_stmt *pLast = 0;
      rc = idxPrepareStmt(dbm, &pLast, pCtx->pzErrmsg, 
          "SELECT max(rowid) FROM sqlite_master"

#endif
    return 1;
  }
  return 0;
}

#ifdef SQLITE_ENABLE_WHEREINFO_HOOK

static void whereTraceWC(
  Parse *pParse, 
  struct SrcList_item *pItem,
  WhereClause *pWC
){
  sqlite3 *db = pParse->db;
  Table *pTab = pItem->pTab;
  void (*x)(void*, int, const char*, int, u64) = db->xWhereInfo;
  void *pCtx = db->pWhereInfoCtx;
  int ii;

  /* Issue callbacks for WO_SINGLE constraints */
  for(ii=0; ii<pTab->nCol; ii++){
    int opMask = WO_SINGLE; 
    WhereScan scan;

      }else{
        eOp = SQLITE_WHEREINFO_RANGE;
      }
      x(pCtx, eOp, (pC ? pC->zName : "BINARY"), ii, pTerm->prereqRight);
    }
  }
}

/*
** If there are any OR terms in WHERE clause pWC, make the associated
** where-info hook callbacks.
*/
static void whereTraceOR(
  Parse *pParse, 
  struct SrcList_item *pItem,
  WhereClause *pWC
){
  sqlite3 *db = pParse->db;
  WhereClause tempWC;
  struct TermAndIdx {
    WhereTerm *pTerm;
    int iIdx;
  } aOr[4];
  int nOr = 0;
  Table *pTab = pItem->pTab;
  int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  int ii;

  memset(aOr, 0, sizeof(aOr));

  /* Iterate through OR nodes */
  for(ii=0; ii<pWC->nTerm; ii++){
    WhereTerm *pTerm = &pWC->a[ii];
    if( pTerm->eOperator & WO_OR ){
      /* Check that each branch of this OR term contains at least
      ** one reference to the table currently being processed. If that
      ** is not the case, this term can be ignored.  */
      WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc;
      WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm];
      WhereTerm *pOrTerm;
      WhereClause *pTermWC;
      WhereScan scan;

      for(pOrTerm=pOrWC->a; pOrTerm<pOrWCEnd; pOrTerm++){
        int iCol;
        if( (pOrTerm->eOperator & WO_AND)!=0 ){
          pTermWC = &pOrTerm->u.pAndInfo->wc;
        }else{
          tempWC.pWInfo = pWC->pWInfo;
          tempWC.pOuter = pWC;
          tempWC.op = TK_AND;
          tempWC.nTerm = 1;
          tempWC.a = pOrTerm;
          pTermWC = &tempWC;
        }

        for(iCol=0; iCol<pTab->nCol; iCol++){
          int iCsr = pItem->iCursor;
          if( !whereScanInit(&scan, pTermWC, iCsr, iCol, WO_SINGLE, 0) ){
            break;
          }
        }
        if( iCol==pTab->nCol ) break;
      }

      if( pOrTerm==pOrWCEnd ){
        aOr[nOr].pTerm = pTerm;
        aOr[nOr].iIdx = pOrWC->nTerm;
        nOr++;
        if( nOr==ArraySize(aOr) ) break;
      }
    }
  }

  while( 1 ){
    for(ii=0; ii<nOr; ii++){
      if( aOr[ii].iIdx==0 ){
        aOr[ii].iIdx = aOr[ii].pTerm->u.pOrInfo->wc.nTerm;
      }else{
        aOr[ii].iIdx--;
        break;
      }
    }
    if( ii==nOr ) break;

    /* Table name callback */
    db->xWhereInfo(db->pWhereInfoCtx, 
        SQLITE_WHEREINFO_TABLE, pTab->zName, iDb, pItem->colUsed
    );
    /* whereTraceWC(pParse, pItem, pWC); */
    for(ii=0; ii<nOr; ii++){
      WhereClause * const pOrWC = &aOr[ii].pTerm->u.pOrInfo->wc;
      if( aOr[ii].iIdx<pOrWC->nTerm ){
        WhereClause *pTermWC;
        WhereTerm *pOrTerm = &pOrWC->a[aOr[ii].iIdx];
        if( (pOrTerm->eOperator & WO_AND)!=0 ){
          pTermWC = &pOrTerm->u.pAndInfo->wc;
        }else{
          tempWC.pWInfo = pWC->pWInfo;
          tempWC.pOuter = pWC;
          tempWC.op = TK_AND;
          tempWC.nTerm = 1;
          tempWC.a = pOrTerm;
          pTermWC = &tempWC;
        }
        whereTraceWC(pParse, pItem, pTermWC);
      }
    }
  }
}

/*
** If there is a where-info hook attached to the database handle, issue all
** required callbacks for the current sqlite3WhereBegin() call.
*/
static void whereTraceBuilder(
  Parse *pParse,
  WhereLoopBuilder *p
){
  sqlite3 *db = pParse->db;
  if( db->xWhereInfo && db->init.busy==0 ){
    void (*x)(void*, int, const char*, int, u64) = db->xWhereInfo;
    void *pCtx = db->pWhereInfoCtx;
    int ii;
    SrcList *pTabList = p->pWInfo->pTabList;

    /* Loop through each element of the FROM clause. Ignore any sub-selects
    ** or views. Invoke the xWhereInfo() callback multiple times for each
    ** real table.  */
    for(ii=0; ii<pTabList->nSrc; ii++){
      struct SrcList_item *pItem = &pTabList->a[ii];
      if( pItem->pSelect==0 ){
        Table *pTab = pItem->pTab;
        int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);

        /* Table name callback */
        x(pCtx, SQLITE_WHEREINFO_TABLE, pTab->zName, iDb, pItem->colUsed);

              }
            }
          }
        }

        /* WHERE callbacks */
        whereTraceWC(pParse, pItem, p->pWC);

        /* OR-clause processing */
        whereTraceOR(pParse, pItem, p->pWC);
      }
    }
  }
}
#else
# define whereTraceBuilder(x,y)
#endif

  SELECT * FROM t5, t6 WHERE a=? AND b=c AND c=?
} {
  CREATE INDEX t5_idx_000123a7 ON t5(a, b) 
  CREATE INDEX t6_idx_00000063 ON t6(c) 
  0|0|1|SEARCH TABLE t6 USING INDEX t6_idx_00000063 (c=?) 
  0|1|0|SEARCH TABLE t5 USING COVERING INDEX t5_idx_000123a7 (a=? AND b=?)
}

# OR terms.
#
do_setup_rec_test 11.1 {
  CREATE TABLE t7(a, b);
} {
  SELECT * FROM t7 WHERE a=? OR b=?
} {
  CREATE INDEX t7_idx_00000061 ON t7(a) 
  CREATE INDEX t7_idx_00000062 ON t7(b)
  0|0|0|SEARCH TABLE t7 USING INDEX t7_idx_00000061 (a=?) 
  0|0|0|SEARCH TABLE t7 USING INDEX t7_idx_00000062 (b=?)
}

finish_test