lib/libc/db/recno/rec_put.c

   1 /*-
   2  * Copyright (c) 1990, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#)rec_put.c        8.7 (Berkeley) 8/18/94
  30  * $FreeBSD: src/lib/libc/db/recno/rec_put.c,v 1.4.6.1 2001/01/02 05:13:25 peter Exp $
  31  * $DragonFly: src/lib/libc/db/recno/rec_put.c,v 1.5 2005/11/19 20:46:32 swildner Exp $
  32  */
  33
  34 #include <sys/types.h>
  35
  36 #include <errno.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40
  41 #include <db.h>
  42 #include "recno.h"
  43
  44 /*
  45  * __REC_PUT -- Add a recno item to the tree.
  46  *
  47  * Parameters:
  48  *      dbp:    pointer to access method
  49  *      key:    key
  50  *      data:   data
  51  *      flag:   R_CURSOR, R_IAFTER, R_IBEFORE, R_NOOVERWRITE
  52  *
  53  * Returns:
  54  *      RET_ERROR, RET_SUCCESS and RET_SPECIAL if the key is
  55  *      already in the tree and R_NOOVERWRITE specified.
  56  */
  57 int
  58 __rec_put(const DB *dbp, DBT *key, const DBT *data, u_int flags)
  59 {
  60         BTREE *t;
  61         DBT fdata, tdata;
  62         recno_t nrec;
  63         int status;
  64
  65         t = dbp->internal;
  66
  67         /* Toss any page pinned across calls. */
  68         if (t->bt_pinned != NULL) {
  69                 mpool_put(t->bt_mp, t->bt_pinned, 0);
  70                 t->bt_pinned = NULL;
  71         }
  72
  73         /*
  74          * If using fixed-length records, and the record is long, return
  75          * EINVAL.  If it's short, pad it out.  Use the record data return
  76          * memory, it's only short-term.
  77          */
  78         if (F_ISSET(t, R_FIXLEN) && data->size != t->bt_reclen) {
  79                 if (data->size > t->bt_reclen)
  80                         goto einval;
  81
  82                 if (t->bt_rdata.size < t->bt_reclen) {
  83                         t->bt_rdata.data =
  84                             reallocf(t->bt_rdata.data, t->bt_reclen);
  85                         if (t->bt_rdata.data == NULL)
  86                                 return (RET_ERROR);
  87                         t->bt_rdata.size = t->bt_reclen;
  88                 }
  89                 memmove(t->bt_rdata.data, data->data, data->size);
  90                 memset((char *)t->bt_rdata.data + data->size,
  91                     t->bt_bval, t->bt_reclen - data->size);
  92                 fdata.data = t->bt_rdata.data;
  93                 fdata.size = t->bt_reclen;
  94         } else {
  95                 fdata.data = data->data;
  96                 fdata.size = data->size;
  97         }
  98
  99         switch (flags) {
 100         case R_CURSOR:
 101                 if (!F_ISSET(&t->bt_cursor, CURS_INIT))
 102                         goto einval;
 103                 nrec = t->bt_cursor.rcursor;
 104                 break;
 105         case R_SETCURSOR:
 106                 if ((nrec = *(recno_t *)key->data) == 0)
 107                         goto einval;
 108                 break;
 109         case R_IAFTER:
 110                 if ((nrec = *(recno_t *)key->data) == 0) {
 111                         nrec = 1;
 112                         flags = R_IBEFORE;
 113                 }
 114                 break;
 115         case 0:
 116         case R_IBEFORE:
 117                 if ((nrec = *(recno_t *)key->data) == 0)
 118                         goto einval;
 119                 break;
 120         case R_NOOVERWRITE:
 121                 if ((nrec = *(recno_t *)key->data) == 0)
 122                         goto einval;
 123                 if (nrec <= t->bt_nrecs)
 124                         return (RET_SPECIAL);
 125                 break;
 126         default:
 127 einval:         errno = EINVAL;
 128                 return (RET_ERROR);
 129         }
 130
 131         /*
 132          * Make sure that records up to and including the put record are
 133          * already in the database.  If skipping records, create empty ones.
 134          */
 135         if (nrec > t->bt_nrecs) {
 136                 if (!F_ISSET(t, R_EOF | R_INMEM) &&
 137                     t->bt_irec(t, nrec) == RET_ERROR)
 138                         return (RET_ERROR);
 139                 if (nrec > t->bt_nrecs + 1) {
 140                         if (F_ISSET(t, R_FIXLEN)) {
 141                                 if ((tdata.data =
 142                                     (void *)malloc(t->bt_reclen)) == NULL)
 143                                         return (RET_ERROR);
 144                                 tdata.size = t->bt_reclen;
 145                                 memset(tdata.data, t->bt_bval, tdata.size);
 146                         } else {
 147                                 tdata.data = NULL;
 148                                 tdata.size = 0;
 149                         }
 150                         while (nrec > t->bt_nrecs + 1)
 151                                 if (__rec_iput(t,
 152                                     t->bt_nrecs, &tdata, 0) != RET_SUCCESS)
 153                                         return (RET_ERROR);
 154                         if (F_ISSET(t, R_FIXLEN))
 155                                 free(tdata.data);
 156                 }
 157         }
 158
 159         if ((status = __rec_iput(t, nrec - 1, &fdata, flags)) != RET_SUCCESS)
 160                 return (status);
 161
 162         switch (flags) {
 163         case R_IAFTER:
 164                 nrec++;
 165                 break;
 166         case R_SETCURSOR:
 167                 t->bt_cursor.rcursor = nrec;
 168                 break;
 169         }
 170
 171         F_SET(t, R_MODIFIED);
 172         return (__rec_ret(t, NULL, nrec, key, NULL));
 173 }
 174
 175 /*
 176  * __REC_IPUT -- Add a recno item to the tree.
 177  *
 178  * Parameters:
 179  *      t:      tree
 180  *      nrec:   record number
 181  *      data:   data
 182  *
 183  * Returns:
 184  *      RET_ERROR, RET_SUCCESS
 185  */
 186 int
 187 __rec_iput(BTREE *t, recno_t nrec, const DBT *data, u_int flags)
 188 {
 189         DBT tdata;
 190         EPG *e;
 191         PAGE *h;
 192         indx_t curindex, nxtindex;
 193         pgno_t pg;
 194         u_int32_t nbytes;
 195         int dflags, status;
 196         char *dest, db[NOVFLSIZE];
 197
 198         /*
 199          * If the data won't fit on a page, store it on indirect pages.
 200          *
 201          * XXX
 202          * If the insert fails later on, these pages aren't recovered.
 203          */
 204         if (data->size > t->bt_ovflsize) {
 205                 if (__ovfl_put(t, data, &pg) == RET_ERROR)
 206                         return (RET_ERROR);
 207                 tdata.data = db;
 208                 tdata.size = NOVFLSIZE;
 209                 *(pgno_t *)db = pg;
 210                 *(u_int32_t *)(db + sizeof(pgno_t)) = data->size;
 211                 dflags = P_BIGDATA;
 212                 data = &tdata;
 213         } else
 214                 dflags = 0;
 215
 216         /* __rec_search pins the returned page. */
 217         if ((e = __rec_search(t, nrec,
 218             nrec > t->bt_nrecs || flags == R_IAFTER || flags == R_IBEFORE ?
 219             SINSERT : SEARCH)) == NULL)
 220                 return (RET_ERROR);
 221
 222         h = e->page;
 223         curindex = e->index;
 224
 225         /*
 226          * Add the specified key/data pair to the tree.  The R_IAFTER and
 227          * R_IBEFORE flags insert the key after/before the specified key.
 228          *
 229          * Pages are split as required.
 230          */
 231         switch (flags) {
 232         case R_IAFTER:
 233                 ++curindex;
 234                 break;
 235         case R_IBEFORE:
 236                 break;
 237         default:
 238                 if (nrec < t->bt_nrecs &&
 239                     __rec_dleaf(t, h, curindex) == RET_ERROR) {
 240                         mpool_put(t->bt_mp, h, 0);
 241                         return (RET_ERROR);
 242                 }
 243                 break;
 244         }
 245
 246         /*
 247          * If not enough room, split the page.  The split code will insert
 248          * the key and data and unpin the current page.  If inserting into
 249          * the offset array, shift the pointers up.
 250          */
 251         nbytes = NRLEAFDBT(data->size);
 252         if (h->upper - h->lower < nbytes + sizeof(indx_t)) {
 253                 status = __bt_split(t, h, NULL, data, dflags, nbytes, curindex);
 254                 if (status == RET_SUCCESS)
 255                         ++t->bt_nrecs;
 256                 return (status);
 257         }
 258
 259         if (curindex < (nxtindex = NEXTINDEX(h)))
 260                 memmove(h->linp + curindex + 1, h->linp + curindex,
 261                     (nxtindex - curindex) * sizeof(indx_t));
 262         h->lower += sizeof(indx_t);
 263
 264         h->linp[curindex] = h->upper -= nbytes;
 265         dest = (char *)h + h->upper;
 266         WR_RLEAF(dest, data, dflags);
 267
 268         ++t->bt_nrecs;
 269         F_SET(t, B_MODIFIED);
 270         mpool_put(t->bt_mp, h, MPOOL_DIRTY);
 271
 272         return (RET_SUCCESS);
 273 }