SQLite4  Check-in [89b4286682]

      bRet = 0;
    }
    *pRc = rc;
  }
  assert( *pRc==LSM_OK || bRet==0 );
  return bRet;
}

/*
** Create a new free-list only top-level segment. Return LSM_OK if successful
** or an LSM error code if some error occurs.
*/
static int sortedNewFreelistOnly(lsm_db *pDb){
  int rc;
  Level *pLvl;

  pLvl = pDb->pWorker->pLevel;
  if( pLvl->pNext!=0 || pLvl->nRight==0 ){
    pLvl = 0;
  }

  rc = sortedNewToplevel(pDb, TREE_NONE, 0);
  if( rc==LSM_OK && pLvl ){
    Level *pNew = pDb->pWorker->pLevel;
    assert( pNew->pNext==pLvl );

    if( pLvl->pSplitKey==0 ){
      sortedSplitkey(pDb, pLvl, &rc);
    }
    if( rc==LSM_OK && pLvl->iSplitTopic==0 ){
      /* Add the new top-level to the rhs of pLvl. */
      Merge *pMerge;

      Segment *aRhs = (Segment *)lsmMallocZeroRc(pDb->pEnv, 
          sizeof(Segment) * (pLvl->nRight + 1), &rc
      );
      if( rc==LSM_OK ){
        memcpy(&aRhs[1], pLvl->aRhs, sizeof(Segment) * pLvl->nRight);
        aRhs[0] = pNew->lhs;
        lsmFree(pDb->pEnv, pLvl->aRhs);
        pLvl->aRhs = aRhs;
        pLvl->nRight++;
      }

      /* Also add an entry to the Merge object */
      pMerge = (Merge *)lsmMallocZeroRc(pDb->pEnv, 
          sizeof(Merge) + sizeof(MergeInput)*(pLvl->pMerge->nInput+1), &rc
      );
      if( rc==LSM_OK ){
        memcpy(pMerge, pLvl->pMerge, sizeof(Merge));
        pMerge->aInput = (MergeInput *)&pMerge[1];
        memcpy(&pMerge->aInput[1], pLvl->pMerge->aInput, 
            sizeof(MergeInput)*(pLvl->pMerge->nInput+1)
        );
        pMerge->aInput[0].iPg = aRhs[0].iFirst;
        pMerge->aInput[0].iCell = 0;
        pMerge->nInput++;
        lsmFree(pDb->pEnv, pLvl->pMerge);
        pLvl->pMerge = pMerge;

        sortedFreeLevel(pDb->pEnv, pNew);
        pDb->pWorker->pLevel = pLvl;
      }
    }
  }

  return rc;
}

int lsmSaveWorker(lsm_db *pDb, int bFlush){
  Snapshot *p = pDb->pWorker;
  if( p->freelist.nEntry>pDb->nMaxFreelist ){
    int rc = sortedNewFreelistOnly(pDb);
    if( rc!=LSM_OK ) return rc;
  }
  return lsmCheckpointSaveWorker(pDb, bFlush);
}

static int doLsmSingleWork(
  lsm_db *pDb, 
  int bShutdown,
  int nMerge,                     /* Minimum segments to merge together */
  int nPage,                      /* Number of pages to write to disk */
  int *pnWrite,                   /* OUT: Pages actually written to disk */
  int *pbCkpt                     /* OUT: True if an auto-checkpoint is req. */
){
  Snapshot *pWorker;              /* Worker snapshot */
  int rc = LSM_OK;                /* Return code */
  int bDirty = 0;
  int nMax = nPage;               /* Maximum pages to write to disk */
  int nRem = nPage;
  int bCkpt = 0;

  /* Open the worker 'transaction'. It will be closed before this function
  ** returns.  */
  assert( pDb->pWorker==0 );
  rc = lsmBeginWork(pDb);
  if( rc!=LSM_OK ) return rc;
  pWorker = pDb->pWorker;

  /* If this connection is doing auto-checkpoints, set nMax (and nRem) so
  ** that this call stops writing when the auto-checkpoint is due. The
  ** caller will do the checkpoint, then possibly call this function again. */
  if( bShutdown==0 && pDb->nAutockpt ){
    u32 nSync;
    u32 nUnsync;

  if( rc==LSM_OK && pDb->pWorker->freelist.nEntry > pDb->nMaxFreelist ){
    int nPg = 0;
    while( rc==LSM_OK && lsmDatabaseFull(pDb) ){
      rc = sortedWork(pDb, 16, nMerge, 1, &nPg);
      nRem -= nPg;
    }
    if( rc==LSM_OK ){
      rc = sortedNewFreelistOnly(pDb);
    }
    nRem -= nPg;
    if( nPg ) bDirty = 1;
  }

  if( rc==LSM_OK && bDirty ){
    lsmFinishWork(pDb, 0, &rc);
  }else{
    int rcdummy = LSM_BUSY;
    lsmFinishWork(pDb, 0, &rcdummy);
  }
  assert( pDb->pWorker==0 );

  if( rc==LSM_OK ){
    *pnWrite = (nMax - nRem);
    *pbCkpt = (bCkpt && nRem<=0);
    if( nMerge==1 && pDb->nAutockpt>0 && bDirty
     && pWorker->pLevel 
     && pWorker->pLevel->nRight==0 
     && pWorker->pLevel->pNext==0 
    ){
      *pbCkpt = 1;
    }
  }else{
    *pnWrite = 0;
    *pbCkpt = 0;
  }

  return rc;
}