sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget);
      sqlite3WalkExprList(pWalker, pUpsert->pUpsertSet);
      sqlite3WalkExpr(pWalker, pUpsert->pUpsertWhere);
      sqlite3WalkExpr(pWalker, pUpsert->pUpsertTargetWhere);
    }
  }
}














/*
** SQL function:
**
**     sqlite_rename_column(zSql, iCol, bQuote, zNew, zTable, zOld)
**
**   0. zSql:     SQL statement to rewrite

  const char *zTable = (const char*)sqlite3_value_text(argv[4]);
  int iCol = sqlite3_value_int(argv[5]);
  const char *zNew = (const char*)sqlite3_value_text(argv[6]);
  int nNew = sqlite3_value_bytes(argv[6]);
  int bQuote = sqlite3_value_int(argv[7]);
  const char *zOld;
  int bTemp = 0;

  int rc;
  char *zErr = 0;
  Parse sParse;
  Walker sWalker;
  Index *pIdx;
  char *zOut = 0;

  int i;
  Table *pTab;




  UNUSED_PARAMETER(NotUsed);
  if( zSql==0 ) return;
  if( zTable==0 ) return;
  if( zNew==0 ) return;
  if( iCol<0 ) return;
  sqlite3BtreeEnterAll(db);
  pTab = sqlite3FindTable(db, zTable, zDb);
  if( pTab==0 || iCol>=pTab->nCol ){
    sqlite3BtreeLeaveAll(db);
    return;
  }
  zOld = pTab->aCol[iCol].zName;
  memset(&sCtx, 0, sizeof(sCtx));
  sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);




  rc = renameParseSql(&sParse, zDb, 0, db, zSql, bTemp);

  /* Find tokens that need to be replaced. */
  memset(&sWalker, 0, sizeof(Walker));
  sWalker.pParse = &sParse;
  sWalker.xExprCallback = renameColumnExprCb;
  sWalker.xSelectCallback = renameColumnSelectCb;

    if( sParse.zErrMsg ){
      renameColumnParseError(context, 0, argv[1], argv[2], &sParse);
    }else{
      sqlite3_result_error_code(context, rc);
    }
  }

  if( sParse.pVdbe ){
    sqlite3VdbeFinalize(sParse.pVdbe);
  }
  sqlite3DeleteTable(db, sParse.pNewTable);
  if( sParse.pNewIndex ) sqlite3FreeIndex(db, sParse.pNewIndex);
  sqlite3DeleteTrigger(db, sParse.pNewTrigger);
  renameTokenFree(db, sParse.pRename);
  renameTokenFree(db, sCtx.pList);
  sqlite3DbFree(db, sParse.zErrMsg);
  sqlite3ParserReset(&sParse);



  sqlite3BtreeLeaveAll(db);
}

static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
  RenameCtx *p = pWalker->u.pRename;
  if( pExpr->op==TK_COLUMN && p->pTab==pExpr->pTab ){
    renameTokenFind(pWalker->pParse, p, (void*)&pExpr->pTab);

/*
** This C function implements an SQL user function that is used by SQL code
** generated by the ALTER TABLE ... RENAME command to modify the definition
** of any foreign key constraints that use the table being renamed as the 
** parent table. It is passed three arguments:
**

**   1) The complete text of the CREATE TABLE statement being modified,
**   2) The old name of the table being renamed, and
**   3) The new name of the table being renamed.

**
** It returns the new CREATE TABLE statement. For example:
**
**   sqlite_rename_table('CREATE TABLE t1(a REFERENCES t2)', 't2', 't3')
**       -> 'CREATE TABLE t1(a REFERENCES t3)'
*/
static void renameTableFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  sqlite3 *db = sqlite3_context_db_handle(context);
  char *zOutput = 0;
  char *zResult;
  unsigned char const *zDb = sqlite3_value_text(argv[0]);
  unsigned char const *zInput = sqlite3_value_text(argv[1]);
  unsigned char const *zOld = sqlite3_value_text(argv[2]);
  unsigned char const *zNew = sqlite3_value_text(argv[3]);
  int bTemp = sqlite3_value_int(argv[4]);


  unsigned const char *z;         /* Pointer to token */
  int n;                          /* Length of token z */
  int token;                      /* Type of token */

  Parse sParse;
  int rc;
  int bQuote = 1;
  RenameCtx sCtx;
  Walker sWalker;





  if( zInput==0 || zOld==0 || zNew==0 ) return;


  memset(&sCtx, 0, sizeof(RenameCtx));
  sCtx.pTab = sqlite3FindTable(db, zOld, zDb);
  memset(&sWalker, 0, sizeof(Walker));
  sWalker.pParse = &sParse;
  sWalker.xExprCallback = renameTableExprCb;
  sWalker.xSelectCallback = renameTableSelectCb;
  sWalker.u.pRename = &sCtx;

  sqlite3BtreeEnterAll(db);

  rc = renameParseSql(&sParse, zDb, 1, db, zInput, bTemp);

  if( rc==SQLITE_OK ){
    if( sParse.pNewTable ){
      Table *pTab = sParse.pNewTable;

      if( pTab->pSelect ){
        NameContext sNC;
        memset(&sNC, 0, sizeof(sNC));
        sNC.pParse = &sParse;

        sqlite3SelectPrep(&sParse, pTab->pSelect, &sNC);
        if( sParse.nErr ) rc = sParse.rc;
        sqlite3WalkSelect(&sWalker, pTab->pSelect);
      }else{
        /* Modify any FK definitions to point to the new table. */
#ifndef SQLITE_OMIT_FOREIGN_KEY
        FKey *pFKey;
        for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
          if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){
            renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo);
          }
        }
#endif

        /* If this is the table being altered, fix any table refs in CHECK
        ** expressions. Also update the name that appears right after the
        ** "CREATE [VIRTUAL] TABLE" bit. */
        if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
          sCtx.pTab = pTab;
          sqlite3WalkExprList(&sWalker, pTab->pCheck);
          renameTokenFind(&sParse, &sCtx, pTab->zName);
        }
      }
    }

    else if( sParse.pNewIndex ){
      renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
      sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
    }

#ifndef SQLITE_OMIT_TRIGGER
    else if( sParse.pNewTrigger ){
      Trigger *pTrigger = sParse.pNewTrigger;
      TriggerStep *pStep;
      if( 0==sqlite3_stricmp(sParse.pNewTrigger->table, zOld) 
       && sCtx.pTab->pSchema==pTrigger->pTabSchema
      ){
        renameTokenFind(&sParse, &sCtx, sParse.pNewTrigger->table);
      }

      rc = renameResolveTrigger(&sParse, bTemp ? 0 : zDb);
      if( rc==SQLITE_OK ){
        renameWalkTrigger(&sWalker, pTrigger);
        for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
          if( pStep->zTarget && 0==sqlite3_stricmp(pStep->zTarget, zOld) ){
            renameTokenFind(&sParse, &sCtx, pStep->zTarget);
          }
        }
      }
    }
#endif
  }

  if( rc==SQLITE_OK ){
    rc = renameEditSql(context, &sCtx, zInput, zNew, bQuote);
  }

  if( rc!=SQLITE_OK ){
    sqlite3_result_error_code(context, rc);
  }
  if( sParse.pVdbe ){
    sqlite3VdbeFinalize(sParse.pVdbe);
  }
  sqlite3DeleteTable(db, sParse.pNewTable);
  if( sParse.pNewIndex ) sqlite3FreeIndex(db, sParse.pNewIndex);
  sqlite3DeleteTrigger(db, sParse.pNewTrigger);
  renameTokenFree(db, sParse.pRename);
  renameTokenFree(db, sCtx.pList);
  sqlite3DbFree(db, sParse.zErrMsg);
  sqlite3ParserReset(&sParse);
  sqlite3BtreeLeaveAll(db);





  return;
}

static void renameTableTest(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  sqlite3 *db = sqlite3_context_db_handle(context);
  unsigned char const *zDb = sqlite3_value_text(argv[0]);
  unsigned char const *zInput = sqlite3_value_text(argv[1]);
  int bTemp = sqlite3_value_int(argv[4]);
  int rc;
  Parse sParse;






  rc = renameParseSql(&sParse, zDb, 1, db, zInput, bTemp);
  if( rc==SQLITE_OK ){
    if( sParse.pNewTable && sParse.pNewTable->pSelect ){
      NameContext sNC;
      memset(&sNC, 0, sizeof(sNC));
      sNC.pParse = &sParse;
      sqlite3SelectPrep(&sParse, sParse.pNewTable->pSelect, &sNC);
      if( sParse.nErr ) rc = sParse.rc;
    }

    else if( sParse.pNewTrigger ){
      rc = renameResolveTrigger(&sParse, bTemp ? 0 : zDb);
    }
  }

  if( rc!=SQLITE_OK ){
    renameColumnParseError(context, 1, argv[2], argv[3], &sParse);
  }

  if( sParse.pVdbe ){
    sqlite3VdbeFinalize(sParse.pVdbe);
  }
  sqlite3DeleteTable(db, sParse.pNewTable);
  if( sParse.pNewIndex ) sqlite3FreeIndex(db, sParse.pNewIndex);
  sqlite3DeleteTrigger(db, sParse.pNewTrigger);
  sqlite3DbFree(db, sParse.zErrMsg);


  renameTokenFree(db, sParse.pRename);
  sqlite3ParserReset(&sParse);
}

/*
** Register built-in functions used to help implement ALTER TABLE
*/
void sqlite3AlterFunctions(void){
  static FuncDef aAlterTableFuncs[] = {

do_test alter-8.2 {
  execsql {
    SELECT a, sum(b) FROM t2 GROUP BY a;
  }
} {1 18 2 9}

#--------------------------------------------------------------------------
# alter-9.X - Special test: Make sure the sqlite_rename_trigger() and
# rename_table() functions do not crash when handed bad input.
#
ifcapable trigger {
  do_test alter-9.1 {
    execsql {SELECT SQLITE_RENAME_TRIGGER(0,0)}
  } {{}}
}
do_test alter-9.2 {
  execsql {
    SELECT SQLITE_RENAME_TABLE(0,0);
    SELECT SQLITE_RENAME_TABLE(10,20);
    SELECT SQLITE_RENAME_TABLE('foo', 'foo');


  }
} {{} {} {}}

#------------------------------------------------------------------------
# alter-10.X - Make sure ALTER TABLE works with multi-byte UTF-8 characters 
# in the names.
#
do_test alter-10.1 {
  execsql "CREATE TABLE xyz(x UNIQUE)"

  SELECT * FROM t16a ORDER BY a;
} {abc 1.25 99 xyzzy cba 5.5 98 fizzle}
do_execsql_test alter-16.2 {
  ALTER TABLE t16a RENAME TO t16a_rn;
  SELECT * FROM t16a_rn ORDER BY a;
} {abc 1.25 99 xyzzy cba 5.5 98 fizzle}

#-------------------------------------------------------------------------
# Verify that NULL values into the internal-use-only sqlite_rename_*()
# functions do not cause problems.
#
do_execsql_test alter-17.1 {
  SELECT sqlite_rename_table('CREATE TABLE xyz(a,b,c)','abc');
} {{CREATE TABLE "abc"(a,b,c)}}
do_execsql_test alter-17.2 {
  SELECT sqlite_rename_table('CREATE TABLE xyz(a,b,c)',NULL);
} {{CREATE TABLE "(NULL)"(a,b,c)}}
do_execsql_test alter-17.3 {
  SELECT sqlite_rename_table(NULL,'abc');
} {{}}
do_execsql_test alter-17.4 {
  SELECT sqlite_rename_trigger('CREATE TRIGGER r1 ON xyz WHEN','abc');
} {{CREATE TRIGGER r1 ON "abc" WHEN}}
do_execsql_test alter-17.5 {
  SELECT sqlite_rename_trigger('CREATE TRIGGER r1 ON xyz WHEN',NULL);
} {{CREATE TRIGGER r1 ON "(NULL)" WHEN}}
do_execsql_test alter-17.6 {
  SELECT sqlite_rename_trigger(NULL,'abc');
} {{}}
do_execsql_test alter-17.7 {
  SELECT sqlite_rename_parent('main', 'CREATE TABLE t1(a REFERENCES "xyzzy")',
         'xyzzy','lmnop');
} {{CREATE TABLE t1(a REFERENCES "lmnop")}}
do_execsql_test alter-17.8 {
  SELECT sqlite_rename_parent('main', 'CREATE TABLE t1(a REFERENCES "xyzzy")',
         'xyzzy',NULL);
} {{}}
do_execsql_test alter-17.9 {
  SELECT sqlite_rename_parent('main', 'CREATE TABLE t1(a REFERENCES "xyzzy")',
         NULL, 'lmnop');
} {{}}
do_execsql_test alter-17.10 {
  SELECT sqlite_rename_parent('main', NULL,'abc','xyz');
} {{}}
do_catchsql_test alter-17.11 {
  SELECT sqlite_rename_parent('main', 'create references ''','abc','xyz');
} {1 {SQL logic error}}
do_catchsql_test alter-17.12 {
  SELECT sqlite_rename_parent('main', 'create references "abc"123" ','abc','xyz');
} {1 {SQL logic error}}
do_catchsql_test alter-17.13 {
  SELECT sqlite_rename_parent('main', "references '''",'abc','xyz');
} {1 {SQL logic error}}

finish_test

    }
  } {{CREATE TABLE t2(a, b, c REFERENCES t1, d DEFAULT NULL REFERENCES t1, e REFERENCES t1 DEFAULT NULL, h DEFAULT 'text' REFERENCES t1)}}
  
  
  # Test the sqlite_rename_parent() function directly.
  #
  proc test_rename_parent {zCreate zOld zNew} {
    db eval {SELECT sqlite_rename_parent($zCreate, $zOld, $zNew)}
  }
  do_test fkey2-14.2.1.1 {
    test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t2 t3
  } {{CREATE TABLE t1(a REFERENCES "t3")}}
  do_test fkey2-14.2.1.2 {
    test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t4 t3
  } {{CREATE TABLE t1(a REFERENCES t2)}}

    }
  } {{CREATE TABLE t2(a, b, c REFERENCES t1, d DEFAULT NULL REFERENCES t1, e REFERENCES t1 DEFAULT NULL, h DEFAULT 'text' REFERENCES t1)}}
  
  
  # Test the sqlite_rename_parent() function directly.
  #
  proc test_rename_parent {zCreate zOld zNew} {
    db eval {SELECT sqlite_rename_parent($zCreate, $zOld, $zNew)}
  }
  do_test without_rowid3-14.2.1.1 {
    test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t2 t3
  } {{CREATE TABLE t1(a REFERENCES "t3")}}
  do_test without_rowid3-14.2.1.2 {
    test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t4 t3
  } {{CREATE TABLE t1(a REFERENCES t2)}}