ind_rem.c

免费的Sql数据库系统

            n2 = 0;
          if (n2 != 0)
            {
              thread_s_put (rbrpn);
              
              if (mlreddi (lkey, lkey2, nkey, nkey2, pn) < 0)
                return (-1);
             }
          else
            putpg (&pgr, 'n');
        }
      else if (n1 + off2 - indphsize < BD_PAGESIZE)
        {			/* merging with r_br*/
          thread_s_put (rbrpn);
          n2 = off2 - indphsize;
          ans = rem_page (lkey, lkey2, &uppn, pn);
          if (ans < 0)
            return (-1);
          pr_merge = 1;
        }
      else
        putpg (&pgr, 'n');
    }
  if (n2 == 0)		/* don't touch right brother */
    if (rloc + elsz == lastb )
      {
        char *newkey, *newk2;
        if (newinf != NULL && rbrpn != (u2_t) ~ 0)
          {
            if (BUF_lockpage (seg_n, rbrpn, 's') == -1) /* Lock rbrpn */
              {
                putwul (pg, 'n');
                return (-1);
              }
            thread_s_put (rbrpn);
          }
        if ( rbeg == asp + indphsize && t2bunpack (rbeg) == 1 && indph->ind_wpage != IROOT)
          {
            u2_t *prevpn_array;
            prevpn_array = (u2_t *) xmalloc(thread_s.count * size2b);
            putwul (pg, 'n');
            ans = rem_last_page(key, key2, prevpn_array, 0);
            xfree(prevpn_array);
            return (ans);
          }
        if (remsz == elsz)
          {
            newkey = key;
            newk2 = key2 - elsz;
          }
        else
          {
            newkey = asp + offbef + size2b;
            newk2 = rbeg - elsz;
          }
        if (rbrpn != (u2_t) ~ 0)
          {
            if (mlreddi (key, key2, newkey, newk2, pn) < 0)
              return (-1);
          }
        else
          {
            if (modlast (key, key2, newkey, newk2, pn) < 0)
              return (-1);
          }
      }
    else
      {
        upunlock ();
        if (lenforce ()< 0)
          return (-1);
      }
  idm = ++((struct p_head *) asp)->idmod;
  icp_remrec (rbeg, rloc, remsz, lastb, elsz, pn, asp, idm);
  if (n2 != 0)
    {
      if (remsz != elsz && rbeg - remsz == lastb)
	bbeg = asp + offbef;
      else
	bbeg = lastb - lbeg;
      lkey = bbeg + size2b;
      a = aspr + indphsize;
      if (cmpkeys (k_n, afn, d_f, lkey, a + size2b) == 0 && n1 != indphsize)
	{
          u2_t keysz;
	  recmjform (OLD, seg_n, pn, idm, bbeg - asp, size2b, bbeg, 0);
          mod_nels (t2bunpack (a), bbeg);
	  keysz = kszcal (a + size2b, afn, d_f);
          off_rbr = keysz + size2b;
          /*	  n2 -= keysz + size2b;*/
	}
      lastb -= remsz;
      bcopy (a + off_rbr, lastb, n2 - off_rbr);
      if (newinf != NULL)
        alter_pn (remsz, elsz, rbeg, rloc, pn, idm, asp, newinf);
      if (pr_merge == 1)
	{
	  a = (char *) &indph->ind_nextpn;
	  recmjform (OLD, seg_n, pn, idm, a - asp, size2b, a, 0);
          indph->ind_nextpn = indphr->ind_nextpn;
          putwul (&pgr, 'n');
          l_emp_put (rbrpn);
          if (ans == 1)
            {			/* remove one level */
              struct A pg1;
              char *asp1; 
              a = (char *) &indph->ind_off;
              recmjform (OLD, seg_n, pn, idm, a - asp, size2b, a, 0);
              indph->ind_off += n2 - remsz;
              asp1 = getwl (&pg1, seg_n, uppn);
              remove_level (asp1, uppn, pg);
              assert (check_ind_page (asp1) == 0);
              putwul (&pg1, 'm');
              return (0);
            }
	}
      else
	{
          i4_t size;
	  a = aspr + indphsize;
          idmr = ++((struct p_head *) aspr)->idmod;
          size = off2 - indphsize - n2;
	  recmjform (COMBL, seg_n, rbrpn, idmr, indphsize, size, a, n2);
          bcopy (a + n2, a, size);
	  a = (char *) &indphr->ind_off;
	  recmjform (OLD, seg_n, rbrpn, idmr, a - aspr, size2b, a, 0);
	  indphr->ind_off -= n2;
          assert (check_ind_page (aspr) == 0);
          putwul (&pgr, 'm');
	}
    }
  else if (newinf != NULL)
    {
      if (rloc + elsz == lastb)
	{
	  aspr = getwl (&pgr, seg_n, rbrpn);	/* get rbrpn without lock */
	  idmr = ++((struct p_head *) aspr)->idmod;
	  a = aspr + indphsize + size2b;
	  a += kszcal (a, afn, d_f);
	  a += k2sz;
	  recmjform (OLD, seg_n, rbrpn, idmr, a - aspr, size2b, a, 0);
          bcopy (newinf, a, size2b);
          assert (check_ind_page (aspr) == 0);
	  putwul (&pgr, 'm');
	}
      else
        alter_pn (remsz, elsz, rbeg, rloc, pn, idm, asp, newinf);
    }
  a = (char *) &indph->ind_off;
  recmjform (OLD, seg_n, pn, idm, a - asp, size2b, a, 0);
  indph->ind_off += n2 - off_rbr - remsz;
  assert (check_ind_page (asp) == 0);
  putwul (pg, 'm');
  return (0);
}

int
icp_rem (struct ldesind *desind, char *key, char *key2, i4_t infsz)
{
  char *asp = NULL;
  u2_t rootpn, d_fn;
  struct ind_page *indph;
  struct A pg;
  
  thread_s_ini_check();
  l_emp_ini_check();
  
  seg_n = desind->i_segn;
  afn = (u2_t *) (desind + 1);
  k_n = desind->ldi.kifn & ~UNIQ & MSK21B;
  uniq_key = UNIQ & desind->ldi.kifn;
  d_f = desind->pdf;
  d_fn = k_n;
  if ((k_n % 2) != 0)
    d_fn += 1;
  d_f2 = (struct des_field *) (afn + d_fn);
  k2sz = d_f2->field_size;
  inf_size = infsz;
  rootpn = desind->ldi.rootpn;
  beg_mop ();
try_again:
  while ((asp = getpg (&pg, seg_n, rootpn, 's')) == NULL);/* Lock and request */
  
  thread_s_ini();
  thread_s_put (rootpn);
  
  indph = (struct ind_page *) asp;
  if (indph->ind_wpage == LEAF)
    {
      i4_t lagelsz, remsz, offbef;
      char  *rbeg, *rloc;
      i4_t idm;
      if (BUF_enforce (seg_n, rootpn) < 0)
	{
	  putwul (&pg, 'n');
	  downunlock ();
	  goto try_again;
	}
      lagelsz = k2sz + infsz;
      remsz = remrep (asp, key, key2, lagelsz, &rbeg, &rloc, &offbef);
      idm = ++((struct p_head *) asp)->idmod;
      icp_remrec (rbeg, rloc, remsz, asp + indph->ind_off, lagelsz, rootpn, asp, idm);
      rloc = (char *) &indph->ind_off;
      recmjform (OLD, seg_n, rootpn, idm, rloc - asp, size2b, rloc, 0);
      indph->ind_off -= remsz;
      assert (check_ind_page (asp) == 0);
      putwul (&pg, 'm');
    }
  else
    {
      if (icp_spusk (&pg, k2sz + size2b, key, key2) == -1)
	{
	  all_unlock ();
	  goto try_again;
	}
      else
	{
	  if (rem_rec (&pg, key, key2, infsz, NULL) < 0)
	    {
	      all_unlock ();
              l_emp_ini();
	      goto try_again;
	    }
	}
    }
  MJ_PUTBL ();
  {
    i4_t  i;
    for (i = 0; i < l_emp.count; i++)
      emptypg (seg_n, l_emp.arr[i], 'f');
    l_emp_ini();
  }
  downunlock ();
  thread_s_ini();
  return (0);
}

int
kszcal (char *key, u2_t * mfn, struct des_field *ad_f)
{
  i4_t k, keysz;
  char *a, *aval;
  u2_t nk;

  keysz = scscal (key);
  assert (keysz < BD_PAGESIZE);
  a = aval = key + keysz;
  for (nk = 0, k = 0; nk < k_n && key < aval; nk++, k++)
    {
      if (k == 7)
	{
	  k = 0;
	  key++;
	}
      if ((*key & BITVL(k)) != 0)
	a = proval (a, (ad_f + mfn[nk])->field_type);
    }
  keysz += a - aval;
  assert (keysz < BD_PAGESIZE);  
  return (keysz);
}

static void
roll_level (u2_t nextpn)
{
  char *asp;
  struct A pg;

  while (nextpn != (u2_t) ~ 0)
    {
      l_emp_put (nextpn);
      thread_s_put (nextpn);
      asp = getpg (&pg, seg_n, nextpn, 's');
      nextpn = ((struct ind_page *) asp)->ind_nextpn;
      putwul (&pg, 'n');
    }
}

int
killind (struct ldesind *desind)
{
  char *asp, *a;
  u2_t pn, nextpn, d_fn;
  struct ind_page *indph;
  struct A pg;

  l_emp_ini_check();
  thread_s_ini_check();
  
  seg_n = desind->i_segn;
  afn = (u2_t *) (desind + 1);
  k_n = desind->ldi.kifn & ~UNIQ & MSK21B;
  d_f = desind->pdf;
  d_fn = k_n;
  if ((k_n % 2) != 0)
    d_fn += 1;
  d_f2 = (struct des_field *) (afn + d_fn);
  k2sz = d_f2->field_size;
  pn = desind->ldi.rootpn;
  for (;;)
    {
      l_emp_put (pn);
      asp = getpg (&pg, seg_n, pn, 's');
      thread_s_put (pn);
      indph = (struct ind_page *) asp;
      if (indph->ind_wpage == LEAF)
	break;
      a = asp + indphsize + size2b;
      a += kszcal (a, afn, d_f) + k2sz;
      pn = t2bunpack (a);
      nextpn = indph->ind_nextpn;
      putwul (&pg, 'n');
      roll_level (nextpn);
    }
  nextpn = indph->ind_nextpn;
  putwul (&pg, 'n');
  roll_level (nextpn);
  {
    i4_t i;
    for (i = 0; i < l_emp.count; i++)
      emptypg (seg_n, l_emp.arr[i], 'f');
    l_emp_ini();
  }
  
  downunlock ();
  thread_s_ini();
  return (0);
}