p->rc = SQLITE_ERROR;
    }
  }

  return p->rc;
}



































static char *otaObjIterGetCollist(
  sqlite3ota *p, 
  OtaObjIter *pIter, 
  int nCol, 
  int *aiCol



){
  char *zList = 0;
  if( p->rc==SQLITE_OK ){
    const char *zSep = "";
    int i;
    for(i=0; i<nCol; i++){
      int iCol = aiCol ? aiCol[i] : i;
      zList = sqlite3_mprintf("%z%s%s", zList, zSep, pIter->azTblCol[iCol]);



      zSep = ", ";
      if( zList==0 ){
        p->rc = SQLITE_NOMEM;
        break;
      }
    }
  }
................................................................................
    if( nOffset ){
      zLimit = sqlite3_mprintf(" LIMIT -1 OFFSET %d", nOffset);
      if( !zLimit ) p->rc = SQLITE_NOMEM;
    }

    if( zIdx ){
      int *aiCol;                 /* Column map */


      /* Create the index writers */
      if( p->rc==SQLITE_OK ){
        p->rc = sqlite3_index_writer(
            p->db, 0, zIdx, &pIter->pInsert, &aiCol, &pIter->nCol
        );
      }
      if( p->rc==SQLITE_OK ){
        p->rc = sqlite3_index_writer(
            p->db, 1, zIdx, &pIter->pDelete, &aiCol, &pIter->nCol
        );
      }

      /* Create the SELECT statement to read keys in sorted order */
      zCollist = otaObjIterGetCollist(p, pIter, pIter->nCol, aiCol);
      if( p->rc==SQLITE_OK ){
        p->rc = prepareFreeAndCollectError(p->db, &pIter->pSelect, pz,
            sqlite3_mprintf(
              "SELECT %s, ota_control FROM ota.'data_%q' "
              "WHERE typeof(ota_control)='integer' AND ota_control!=1 "
                "UNION ALL "
              "SELECT %s, ota_control FROM ota.'ota_tmp_%q' "
................................................................................
        );
      }
    }else{
      char *zBindings = otaObjIterGetBindlist(p, pIter->nTblCol);
      char *zWhere = otaObjIterGetWhere(p, pIter);
      char *zOldlist = otaObjIterGetOldlist(p, pIter, "old");
      char *zNewlist = otaObjIterGetOldlist(p, pIter, "new");
      zCollist = otaObjIterGetCollist(p, pIter, pIter->nTblCol, 0);
      pIter->nCol = pIter->nTblCol;

      /* Create the SELECT statement to read keys from data_xxx */
      if( p->rc==SQLITE_OK ){
        p->rc = prepareFreeAndCollectError(p->db, &pIter->pSelect, pz,
            sqlite3_mprintf(
              "SELECT %s, ota_control FROM ota.'data_%q'%s", 

      p->rc = SQLITE_ERROR;
    }
  }

  return p->rc;
}

/*
** This function constructs and returns a pointer to a nul-terminated 
** string containing some SQL clause or list based on one or more of the 
** column names currently stored in the pIter->azTblCol[] array.
**
** If an OOM error is encountered, NULL is returned and an error code
** left in the OTA handle passed as the first argument. Otherwise, a pointer
** to the allocated string buffer is returned. It is the responsibility
** of the caller to eventually free this buffer using sqlite3_free().
**
** The number of column names to include in the returned string is passed
** as the third argument.
**
** If arguments aiCol and azCollate are both NULL, then the returned string
** contains the first nCol column names as a comma-separated list. For 
** example:
**
**     "a", "b", "c"
**
** If argument aiCol is not NULL, it must point to an array containing nCol
** entries - the index of each column name to include in the comma-separated
** list. For example, if aiCol[] contains {2, 0, 1), then the returned 
** string is changed to:
**
**     "c", "a", "b"
**
** If azCollate is not NULL, it must also point to an array containing nCol
** entries - collation sequence names to associated with each element of
** the comma separated list. For example, ef azCollate[] contains 
** {"BINARY", "NOCASE", "REVERSE"}, then the retuned string is:
**
**     "c" COLLATE "BINARY", "a" COLLATE "NOCASE", "b" COLLATE "REVERSE"
**
*/
static char *otaObjIterGetCollist(
  sqlite3ota *p,                  /* OTA object */
  OtaObjIter *pIter,              /* Object iterator for column names */


  int nCol,                       /* Number of column names */
  int *aiCol,                     /* Array of nCol column indexes */
  const char **azCollate          /* Array of nCol collation sequence names */
){
  char *zList = 0;
  if( p->rc==SQLITE_OK ){
    const char *zSep = "";
    int i;
    for(i=0; i<nCol; i++){
      int iCol = aiCol ? aiCol[i] : i;
      zList = sqlite3_mprintf("%z%s%s", zList, zSep, pIter->azTblCol[iCol]);
      if( zList && azCollate ){
        zList = sqlite3_mprintf("%z COLLATE %Q", zList, azCollate[i]);
      }
      zSep = ", ";
      if( zList==0 ){
        p->rc = SQLITE_NOMEM;
        break;
      }
    }
  }
................................................................................
    if( nOffset ){
      zLimit = sqlite3_mprintf(" LIMIT -1 OFFSET %d", nOffset);
      if( !zLimit ) p->rc = SQLITE_NOMEM;
    }

    if( zIdx ){
      int *aiCol;                 /* Column map */
      const char **azColl;        /* Collation sequences */

      /* Create the index writers */
      if( p->rc==SQLITE_OK ){
        p->rc = sqlite3_index_writer(
            p->db, 0, zIdx, &pIter->pInsert, &azColl, &aiCol, &pIter->nCol
        );
      }
      if( p->rc==SQLITE_OK ){
        p->rc = sqlite3_index_writer(
            p->db, 1, zIdx, &pIter->pDelete, &azColl, &aiCol, &pIter->nCol
        );
      }

      /* Create the SELECT statement to read keys in sorted order */
      zCollist = otaObjIterGetCollist(p, pIter, pIter->nCol, aiCol, azColl);
      if( p->rc==SQLITE_OK ){
        p->rc = prepareFreeAndCollectError(p->db, &pIter->pSelect, pz,
            sqlite3_mprintf(
              "SELECT %s, ota_control FROM ota.'data_%q' "
              "WHERE typeof(ota_control)='integer' AND ota_control!=1 "
                "UNION ALL "
              "SELECT %s, ota_control FROM ota.'ota_tmp_%q' "
................................................................................
        );
      }
    }else{
      char *zBindings = otaObjIterGetBindlist(p, pIter->nTblCol);
      char *zWhere = otaObjIterGetWhere(p, pIter);
      char *zOldlist = otaObjIterGetOldlist(p, pIter, "old");
      char *zNewlist = otaObjIterGetOldlist(p, pIter, "new");
      zCollist = otaObjIterGetCollist(p, pIter, pIter->nTblCol, 0, 0);
      pIter->nCol = pIter->nTblCol;

      /* Create the SELECT statement to read keys from data_xxx */
      if( p->rc==SQLITE_OK ){
        p->rc = prepareFreeAndCollectError(p->db, &pIter->pSelect, pz,
            sqlite3_mprintf(
              "SELECT %s, ota_control FROM ota.'data_%q'%s", 

** to insert operations.
*/
int sqlite3_index_writer(
  sqlite3 *db, 
  int bDelete,                    /* Zero for insert, non-zero for delete */
  const char *zIndex,             /* Index to write to */
  sqlite3_stmt**,                 /* OUT: New statement handle */

  int **paiCol, int *pnCol        /* OUT: See above */
);

/*
** This function is used to save the state of an ongoing WAL mode write 
** transaction on the "main" database of the supplied database handle.
**

** to insert operations.
*/
int sqlite3_index_writer(
  sqlite3 *db, 
  int bDelete,                    /* Zero for insert, non-zero for delete */
  const char *zIndex,             /* Index to write to */
  sqlite3_stmt**,                 /* OUT: New statement handle */
  const char ***pazColl,          /* OUT: Collation sequences for each column */
  int **paiCol, int *pnCol        /* OUT: See above */
);

/*
** This function is used to save the state of an ongoing WAL mode write 
** transaction on the "main" database of the supplied database handle.
**

  }

  rc = sqlite3ApiExit(db, rc);
  assert( rc==SQLITE_OK || p->pStmt==0 );
  sqlite3_mutex_leave(db->mutex);
  return rc;
}
































































int sqlite3_index_writer(
  sqlite3 *db, 
  int bDelete,
  const char *zIndex, 
  sqlite3_stmt **ppStmt,
  int **paiCol, int *pnCol



){
  int rc = SQLITE_OK;
  Parse *pParse = 0;
  Index *pIdx = 0;                /* The index to write to */
  Table *pTab;
  int i;                          /* Used to iterate through index columns */
  Vdbe *v = 0;
  int regRec;                     /* Register to assemble record in */
  int *aiCol = 0;
  const char *zAffinity = 0;      /* Affinity string for the current index */

  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);

  /* Allocate the parse context */
  pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
................................................................................
  if( pIdx==0 ){
    sqlite3ErrorMsg(pParse, "no such index: %s", zIndex);
    goto index_writer_out;
  }
  pTab = pIdx->pTable;
  zAffinity = sqlite3IndexAffinityStr(v, pIdx);

  /* Populate the two output variables, *pnCol and *pnAiCol. */
  *pnCol = pIdx->nColumn;
  *paiCol = aiCol = sqlite3DbMallocZero(db, sizeof(int) * pIdx->nColumn);
  if( aiCol==0 ){
    rc = SQLITE_NOMEM;
    goto index_writer_out;
  }
  for(i=0; i<pIdx->nKeyCol; i++){
    aiCol[i] = pIdx->aiColumn[i];
  }
  if( !HasRowid(pTab) ){
    Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
    assert( pIdx->nColumn==pIdx->nKeyCol+pPk->nKeyCol );
    if( pPk==pIdx ){
      rc = SQLITE_ERROR;
      goto index_writer_out;
    }
    for(i=0; i<pPk->nKeyCol; i++){
      aiCol[pIdx->nKeyCol+i] = pPk->aiColumn[i];
    }
  }else{
    assert( pIdx->nColumn==pIdx->nKeyCol+1 );
    aiCol[i] = pTab->iPKey;
  }

  /* Add an OP_Noop to the VDBE program. Then store a pointer to the 
  ** output array *paiCol as its P4 value. This is so that the array
  ** is automatically deleted when the user finalizes the statement. The
  ** OP_Noop serves no other purpose. */
  sqlite3VdbeAddOp0(v, OP_Noop);
  sqlite3VdbeChangeP4(v, -1, (const char*)aiCol, P4_INTARRAY);

  sqlite3BeginWriteOperation(pParse, 0, 0);

  /* Open a write cursor on the index */
  pParse->nTab = 1;
  sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, pIdx->tnum, 0);
  sqlite3VdbeSetP4KeyInfo(pParse, pIdx);

  }

  rc = sqlite3ApiExit(db, rc);
  assert( rc==SQLITE_OK || p->pStmt==0 );
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

static int indexWriterOutputVars(
  sqlite3 *db,
  Index *pIdx,
  const char ***pazColl,          /* OUT: Array of collation sequences */
  int **paiCol,                   /* OUT: Array of column indexes */
  int *pnCol                      /* OUT: Total columns in index keys */
){
  Table *pTbl = pIdx->pTable;     /* Table index is attached to */
  Index *pPk = 0;
  int nByte = 0;                  /* Total bytes of space to allocate */
  int i;                          /* Iterator variable */

  int *aiCol;
  const char **azColl;
  char *pCsr;

  if( !HasRowid(pTbl) ){
    pPk = sqlite3PrimaryKeyIndex(pTbl);
  }

  for(i=0; i<pIdx->nColumn; i++){
    const char *zColl = 0;
    if( i<pIdx->nKeyCol ){
      zColl = pIdx->azColl[i];
    }else if( pPk ){
      zColl = pPk->azColl[i-pIdx->nKeyCol];
    }
    if( zColl==0 ) zColl = "BINARY";
    nByte += sqlite3Strlen30(zColl) + 1;
  }
  nByte += (pIdx->nColumn) * (sizeof(const char*) + sizeof(int));

  /* Populate the output variables */
  *pazColl = azColl = (const char**)sqlite3DbMallocZero(db, nByte);
  if( azColl==0 ) return SQLITE_NOMEM;
  *paiCol = aiCol = (int*)&azColl[pIdx->nColumn];
  *pnCol = pIdx->nColumn;
  pCsr = (char*)&aiCol[pIdx->nColumn];

  for(i=0; i<pIdx->nColumn; i++){
    const char *zColl = 0;
    int nColl;
    int iCol = pTbl->iPKey;
    if( i<pIdx->nKeyCol ){
      zColl = pIdx->azColl[i];
      iCol = pIdx->aiColumn[i];
    }else if( pPk ){
      zColl = pPk->azColl[i-pIdx->nKeyCol];
      iCol = pPk->aiColumn[i-pIdx->nKeyCol];
    }
    if( zColl==0 ) zColl = "BINARY";

    aiCol[i] = iCol;
    azColl[i] = pCsr;
    nColl = 1 + sqlite3Strlen30(zColl);
    memcpy(pCsr, zColl, nColl);
    pCsr += nColl;
  }

  return SQLITE_OK;
}


int sqlite3_index_writer(
  sqlite3 *db, 
  int bDelete,
  const char *zIndex, 
  sqlite3_stmt **ppStmt,

  const char ***pazColl,          /* OUT: Array of collation sequences */
  int **paiCol,                   /* OUT: Array of column indexes */
  int *pnCol                      /* OUT: Total columns in index keys */
){
  int rc = SQLITE_OK;
  Parse *pParse = 0;
  Index *pIdx = 0;                /* The index to write to */
  Table *pTab;
  int i;                          /* Used to iterate through index columns */
  Vdbe *v = 0;
  int regRec;                     /* Register to assemble record in */

  const char *zAffinity = 0;      /* Affinity string for the current index */

  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);

  /* Allocate the parse context */
  pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
................................................................................
  if( pIdx==0 ){
    sqlite3ErrorMsg(pParse, "no such index: %s", zIndex);
    goto index_writer_out;
  }
  pTab = pIdx->pTable;
  zAffinity = sqlite3IndexAffinityStr(v, pIdx);

  rc = indexWriterOutputVars(db, pIdx, pazColl, paiCol, pnCol);




  if( rc!=SQLITE_OK ) goto index_writer_out;



















  /* Add an OP_Noop to the VDBE program. Then store a pointer to the 
  ** output array *paiCol as its P4 value. This is so that the array
  ** is automatically deleted when the user finalizes the statement. The
  ** OP_Noop serves no other purpose. */
  sqlite3VdbeAddOp0(v, OP_Noop);
  sqlite3VdbeChangeP4(v, -1, (const char*)(*pazColl), P4_INTARRAY);

  sqlite3BeginWriteOperation(pParse, 0, 0);

  /* Open a write cursor on the index */
  pParse->nTab = 1;
  sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, pIdx->tnum, 0);
  sqlite3VdbeSetP4KeyInfo(pParse, pIdx);