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