eyedb: api.cc Source File

00001 /* 
00002    EyeDB Object Database Management System
00003    Copyright (C) 1994-2008 SYSRA
00004    
00005    EyeDB is free software; you can redistribute it and/or
00006    modify it under the terms of the GNU Lesser General Public
00007    License as published by the Free Software Foundation; either
00008    version 2.1 of the License, or (at your option) any later version.
00009    
00010    EyeDB is distributed in the hope that it will be useful,
00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013    Lesser General Public License for more details.
00014    
00015    You should have received a copy of the GNU Lesser General Public
00016    License along with this library; if not, write to the Free Software
00017    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA 
00018 */
00019 
00020 /*
00021   Author: Eric Viara <viara@sysra.com>
00022 */
00023 
00024 #include <eyedbconfig.h>
00025 
00026 #include <pthread.h>
00027 
00028 #include <unistd.h>
00029 #include <stdlib.h>
00030 
00031 #include <eyedblib/iassert.h>
00032 #include "transaction.h"
00033 #include "kern.h"
00034 #include "lock.h"
00035 // added 4/05
00036 #include "eyedbsm_p.h"
00037 #include <eyedblib/m_mem.h>
00038 #include "lib/m_mem_p.h"
00039 
00040 namespace eyedbsm {
00041   /*extern "C" */ Boolean
00042   isPhy(DbHandle const *dbh, const Oid *oid);
00043 
00044   //static StatusRec status_r;
00045 
00046 #define STATUS_RETURN(S) \
00047 return (((S).err == SUCCESS) ? Success : &(S))
00048 
00049   /*
00050     static void fe_statusMake(ClientArg *ua, int i)
00051     {
00052     static unsigned int status_alloc;
00053     StatusProtocol *s = &ua[i].a_status;
00054 
00055     status_r.err = (Error)s->err;
00056     if (strlen(s->err_msg) >= status_alloc) {
00057     status_alloc = strlen(s->err_msg)+10;
00058     status_r.err_msg = (char *)realloc(status_r.err_msg, status_alloc);
00059     }
00060 
00061     strcpy(status_r.err_msg, s->err_msg);
00062     }
00063   */
00064 
00065   /*
00066     Status
00067     connOpen(const char *hostname, const char *portname, ConnHandle **pch,
00068     int flags)
00069     {
00070     return Success;
00071     }
00072 
00073     Status
00074     connClose(ConnHandle *ch)
00075     {
00076     return Success;
00077     }
00078   */
00079 
00080   int
00081   getOpenFlags(DbHandle const *dbh)
00082   {
00083     return ESM_getOpenFlags((DbHandle *)dbh);
00084   }
00085 
00086   Status
00087   transactionBegin(DbHandle *dbh, const TransactionParams *params)
00088   {
00089     Status se;
00090     se = ESM_transactionBegin((DbHandle *)dbh, params);
00091     if (!se)
00092       dbh->tr_cnt++;
00093     return se;
00094   }
00095 
00096   Status
00097   transactionParamsSet(DbHandle const *dbh,
00098                        const TransactionParams *params)
00099   {
00100     /*  return ESM_transactionParamsSet(dbh, trmode, trwrmode, params);*/
00101     /* changed dbh to (DbHandle *)dbh 11/11/00 */
00102     return ESM_transactionParamsSet((DbHandle *)dbh, params);
00103   }
00104 
00105   Status
00106   transactionParamsGet(DbHandle const *dbh,
00107                        TransactionParams *params)
00108   {
00109     return ESM_transactionParamsGet(dbh, params);
00110   }
00111 
00112   Status
00113   transactionCommit(DbHandle *dbh)
00114   {
00115     Status se;
00116     if (!dbh->tr_cnt)
00117       return statusMake(TRANSACTION_NEEDED, "transactionCommit");
00118 
00119     se = ESM_transactionCommit((DbHandle *)dbh);
00120     if (!se)
00121       dbh->tr_cnt--;
00122     return se;
00123   }
00124 
00125   Status
00126   transactionAbort(DbHandle *dbh)
00127   {
00128     Status se;
00129     if (!dbh->tr_cnt)
00130       return statusMake(TRANSACTION_NEEDED, "transactionAbort");
00131 
00132     se = ESM_transactionAbort((DbHandle *)dbh);
00133     if (!se)
00134       dbh->tr_cnt--;
00135     return se;
00136   }
00137 
00138   /* remote procedure calls */
00139   Status
00140   dbOpen(const char *dbfile, int flags,
00141          const OpenHints *hints, int uid, unsigned int *pversion,
00142          DbHandle **dbh)
00143   {
00144     Status status;
00145       
00146     *dbh = (DbHandle *)m_calloc(sizeof(DbHandle), 1);
00147     memset(*dbh, 0, sizeof(**dbh));
00148 
00149     status = ESM_dbOpen(dbfile, flags & ~LOCAL, hints, 0, 0, 0, 0, pversion, dbh);
00150       
00151     if (!status) {
00152       //(*dbh)->ldbctx.rdbhid = 0;
00153       //(*dbh)->ldbctx.xid    = ESM_xidGet(tdbh);
00154       (*dbh)->xid    = ESM_xidGet(*dbh);
00155       ESM_uidSet(*dbh, uid);
00156       ESM_suserUnset(*dbh);
00157       //(*dbh) = tdbh;
00158       (*dbh)->flags = flags & ~LOCAL;
00159       //printf("dbOpen: dbh=%p\n", *dbh);
00160       //printf("dbOpen: dbh=%p\n", (*dbh));
00161     }
00162   
00163     return status;
00164   }
00165 
00166   Status
00167   dbClose(const DbHandle *dbh)
00168   {
00169     //printf("dbClose: dbh=%p\n", dbh);
00170     //printf("dbClose: dbh=%p\n", dbh);
00171     return ESM_dbClose((DbHandle *)dbh);
00172   }
00173 
00174   Status
00175   rootEntrySet(DbHandle const *dbh, char const *const key,
00176                void const *const data, unsigned int size, Boolean create)
00177   {
00178     if (!dbh->tr_cnt)
00179       return statusMake(TRANSACTION_NEEDED, "rootEntrySet");
00180     return ESM_rootEntrySet((DbHandle *)dbh, key, data, size, create);
00181   }
00182 
00183   Status
00184   rootEntryGet(DbHandle const *dbh, char const *const key,
00185                void *data, unsigned int maxsize)
00186   {
00187     if (!dbh->tr_cnt)
00188       return statusMake(TRANSACTION_NEEDED, "rootEntryGet");
00189     return ESM_rootEntryGet((DbHandle *)dbh, key, data, maxsize);
00190   }
00191 
00192   Status
00193   rootEntryDelete(DbHandle const *dbh, char const *const key)
00194   {
00195     if (!dbh->tr_cnt)
00196       return statusMake(TRANSACTION_NEEDED, "rootEntryDelete");
00197     return ESM_rootEntryDelete((DbHandle *)dbh, key);
00198   }
00199 
00200   Status
00201   objectCreate(DbHandle const *dbh, void const *const object,
00202                unsigned int size, short dspid, Oid *oid)
00203   {
00204     if (!dbh->tr_cnt)
00205       return statusMake(TRANSACTION_NEEDED, "objectCreate");
00206     return ESM_objectCreate((DbHandle *)dbh, object, size, dspid, oid, OPDefault);
00207   }
00208 
00209   Boolean
00210   isPhysicalOid(DbHandle const *dbh, const Oid *oid)
00211   {
00212     return isPhy((DbHandle *)dbh, oid);
00213   }
00214 
00215   Status
00216   objectDelete(DbHandle const *dbh, Oid const *const oid)
00217   {
00218     if (!dbh->tr_cnt)
00219       return statusMake(TRANSACTION_NEEDED, "objectDelete");
00220 
00221     return ESM_objectDelete((DbHandle *)dbh, oid, OPDefault);
00222   }
00223 
00224   Status
00225   objectWrite(DbHandle const *dbh, int start, int length,
00226               void const *const object, Oid const *const oid)
00227   {
00228     if (!dbh->tr_cnt)
00229       return statusMake(TRANSACTION_NEEDED, "objectWrite");
00230 
00231     return ESM_objectWrite((DbHandle *)dbh, start, length, object, oid, OPDefault);
00232   }
00233 
00234   Status
00235   objectWriteCache(DbHandle const *dbh, int start,
00236                    void const *const object, Oid const *const oid)
00237   {
00238     if (!dbh->tr_cnt)
00239       return statusMake(TRANSACTION_NEEDED, "objectWriteCache");
00240 
00241     return ESM_objectWriteCache((DbHandle *)dbh, start, object, oid);
00242   }
00243 
00244   Status
00245   objectMoveDat(DbHandle const *dbh, Oid const *const oid,
00246                 short datid)
00247   {
00248     if (!dbh->tr_cnt)
00249       return statusMake(TRANSACTION_NEEDED, "objectMoveDat");
00250     return ESM_objectMoveDatDsp((DbHandle *)dbh, oid, datid, -1, False, OPDefault);
00251   }
00252 
00253   Status
00254   objectsMoveDat(DbHandle const *dbh, Oid const *const oid,
00255                  unsigned int oid_cnt, short datid)
00256   {
00257     if (!dbh->tr_cnt)
00258       return statusMake(TRANSACTION_NEEDED, "objectsMoveDat");
00259     return ESM_objectsMoveDatDsp((DbHandle *)dbh, oid, oid_cnt, datid, -1, False, OPDefault);
00260   }
00261 
00262   Status
00263   objectMoveDsp(DbHandle const *dbh, Oid const *const oid,
00264                 short dspid)
00265   {
00266     if (!dbh->tr_cnt)
00267       return statusMake(TRANSACTION_NEEDED, "objectMoveDsp");
00268     return ESM_objectMoveDatDsp((DbHandle *)dbh, oid, -1, dspid, False, OPDefault);
00269   }
00270 
00271   Status
00272   objectsMoveDsp(DbHandle const *dbh, Oid const *const oid,
00273                  unsigned int oid_cnt, short dspid)
00274   {
00275     if (!dbh->tr_cnt)
00276       return statusMake(TRANSACTION_NEEDED, "objectsMoveDsp");
00277     return ESM_objectsMoveDatDsp((DbHandle *)dbh, oid, oid_cnt, -1, dspid, False, OPDefault);
00278   }
00279 
00280   Status
00281   objectLock(DbHandle const *dbh, Oid const *const oid, 
00282              LockMode mode, LockMode *rmode)
00283   {
00284     int lockmode;
00285     Status se;
00286 
00287     if (!oid->getNX() && !isPhysicalOid(dbh, oid))
00288       return statusMake(ERROR, "object lock: invalid null oid");
00289     
00290     if (!dbh->tr_cnt)
00291       return statusMake(TRANSACTION_NEEDED, "objectLock");
00292 
00293     if (mode == LockX)
00294       lockmode = LOCKX;
00295     else if (mode == LockS)
00296       lockmode = LOCKS;
00297     else if (mode == LockSX)
00298       lockmode = LOCKSX;
00299     else if (mode == LockN)
00300       lockmode = LOCKN;
00301     else
00302       return statusMake(ERROR, "invalid lock mode %d", mode);
00303 
00304     se = ESM_objectLock((DbHandle *)dbh, oid, (TransactionOP)(OREAD|lockmode), NULL, NULL);
00305     if (se) return se;
00306 
00307     if (rmode)
00308       ESM_objectGetLock((DbHandle *)dbh, oid, rmode);
00309 
00310     return Success;
00311   }
00312 
00313   Status
00314   objectGetLock(DbHandle const *dbh, Oid const *const oid,
00315                 LockMode *rmode)
00316   {
00317     if (!oid->getNX() && !isPhysicalOid(dbh, oid))
00318       return statusMake(ERROR, "object lock: invalid null oid");
00319     
00320     if (!dbh->tr_cnt)
00321       return statusMake(TRANSACTION_NEEDED, "objectLock");
00322 
00323     if (rmode)
00324       return ESM_objectGetLock((DbHandle *)dbh, oid, rmode);
00325     return Success;
00326   }
00327 
00328   Status
00329   objectDownLock(DbHandle const *dbh, Oid const *const oid)
00330   {
00331     if (!dbh->tr_cnt)
00332       return statusMake(TRANSACTION_NEEDED, "objectDownLock");
00333     return ESM_objectDownLock((DbHandle *)dbh, oid);
00334   }
00335 
00336   Status
00337   transactionLockSet(DbHandle const *dbh, ObjectLockMode lockmode,
00338                      ObjectLockMode *omode)
00339   {
00340     if (!dbh->tr_cnt)
00341       return statusMake(TRANSACTION_NEEDED, "transactionLockSet");
00342     return ESM_transactionLockSet((DbHandle *)dbh, lockmode, omode);
00343   }
00344 
00345   Status
00346   objectRead(DbHandle const *dbh, int start, int length, void *object,
00347              LockMode lockmode, short *pdatid, unsigned int *psize,
00348              Oid const *const oid)
00349   {
00350     if (!dbh->tr_cnt)
00351       return statusMake(TRANSACTION_NEEDED, "objectRead");
00352     return ESM_objectRead((DbHandle *)dbh, start, length, object,
00353                           lockmode, pdatid, psize, oid, OPDefault);
00354   }
00355 
00356   Status
00357   objectReadNoCopy(DbHandle const *dbh, int start, int length,
00358                    void *object, LockMode lockmode, short *pdatid,
00359                    unsigned int *psize, Oid const *const oid)
00360   {
00361     if (!dbh->tr_cnt)
00362       return statusMake(TRANSACTION_NEEDED, "objectReadNoCopy");
00363     return ESM_objectReadNoCopy((DbHandle *)dbh, start, length, object,
00364                                 lockmode, pdatid, psize, oid, OPDefault);
00365   }
00366 
00367   Status
00368   objectReadCache(DbHandle const *dbh, int start, void **object,
00369                   LockMode lockmode, Oid const *const oid)
00370   {
00371     if (!dbh->tr_cnt)
00372       return statusMake(TRANSACTION_NEEDED, "objectReadCache");
00373     return ESM_objectReadCache((DbHandle *)dbh, start, object, lockmode, oid);
00374   }
00375 
00376   Status
00377   objectSizeGet(DbHandle const *dbh, unsigned int *size, LockMode lockmode,
00378                 Oid const *const oid)
00379   {
00380     if (!dbh->tr_cnt)
00381       return statusMake(TRANSACTION_NEEDED, "objectSizeGet");
00382     return ESM_objectSizeGet((DbHandle *)dbh, size, lockmode, oid, OPDefault);
00383   }
00384 
00385   Status
00386   objectSizeModify(DbHandle const *dbh, unsigned int size, Boolean copy,
00387                    Oid const *const oid)
00388   {
00389     if (!dbh->tr_cnt)
00390       return statusMake(TRANSACTION_NEEDED, "objectSizeModify");
00391     return ESM_objectSizeModify((DbHandle *)dbh, size, copy, oid, OPDefault);
00392   }
00393 
00394   Status
00395   objectCheckAccess(DbHandle const *dbh, Boolean write,
00396                     Oid const *const oid, Boolean *access)
00397   {
00398     return ESM_objectCheckAccess((DbHandle *)dbh, write, oid, access);
00399   }
00400 
00401   Status
00402   objectLocationGet(DbHandle const *dbh, const Oid *oid,
00403                     ObjectLocation *objloc)
00404   {
00405     if (!dbh->tr_cnt)
00406       return statusMake(TRANSACTION_NEEDED, "objectLocationGet");
00407     return ESM_objectLocationGet((DbHandle *)dbh, oid, objloc);
00408   }
00409   
00410   Status
00411   objectsLocationGet(DbHandle const *dbh, const Oid *oid,
00412                      ObjectLocation *objloc, unsigned int oid_cnt)
00413   {
00414     if (!dbh->tr_cnt)
00415       return statusMake(TRANSACTION_NEEDED, "objectsLocationGet");
00416     return ESM_objectsLocationGet((DbHandle *)dbh, oid, objloc, oid_cnt);
00417   }
00418   
00419   /*
00420     Status
00421     firstOidGet(DbHandle const *dbh, Oid *oid, Boolean *found)
00422     {
00423     if (!dbh->tr_cnt)
00424     return statusMake(TRANSACTION_NEEDED, "firstOidGet");
00425     return ESM_firstOidGet((DbHandle *)dbh, oid, found);
00426     }
00427 
00428     Status
00429     nextOidGet(DbHandle const *dbh, Oid const *const baseoid,
00430     Oid *nextoid, Boolean *found)
00431     {
00432     if (!dbh->tr_cnt)
00433     return statusMake(TRANSACTION_NEEDED, "nextOidGet");
00434     return ESM_nextOidGet((DbHandle *)dbh, baseoid, nextoid, found);
00435     }
00436   */
00437 
00438   Status
00439   firstOidDatGet(DbHandle const *dbh, short datid, Oid *oid,
00440                  Boolean *found)
00441   {
00442     if (!dbh->tr_cnt)
00443       return statusMake(TRANSACTION_NEEDED, "firstOidGet");
00444     return ESM_firstOidDatGet((DbHandle *)dbh, datid, oid, found);
00445   }
00446 
00447   Status
00448   nextOidDatGet(DbHandle const *dbh, short datid,
00449                 Oid const *const baseoid,
00450                 Oid *nextoid, Boolean *found)
00451   {
00452     if (!dbh->tr_cnt)
00453       return statusMake(TRANSACTION_NEEDED, "nextOidGet");
00454     return ESM_nextOidDatGet((DbHandle *)dbh, datid, baseoid, nextoid, found);
00455   }
00456 
00457   Status
00458   suserUnset(DbHandle *dbh)
00459   {
00460     if (!dbh->tr_cnt)
00461       return statusMake(TRANSACTION_NEEDED, "suserUnset");
00462     return ESM_suserUnset((DbHandle *)dbh);
00463   }
00464 
00465   Status
00466   protectionCreate(DbHandle const *dbh,
00467                    ProtectionDescription const *desc,
00468                    Oid *oid)
00469   {
00470     if (!dbh->tr_cnt)
00471       return statusMake(TRANSACTION_NEEDED, "protectionCreate");
00472 
00473     return ESM_protectionCreate((DbHandle *)dbh, desc, oid);
00474   }
00475 
00476   Status
00477   protectionDelete(DbHandle const *dbh, Oid const *const oid)
00478   {
00479     if (!dbh->tr_cnt)
00480       return statusMake(TRANSACTION_NEEDED, "protectionDelete");
00481     return ESM_protectionDelete((DbHandle *)dbh, oid);
00482   }
00483 
00484   Status
00485   protectionModify(DbHandle const *dbh,
00486                    ProtectionDescription const *desc,
00487                    Oid const *oid)
00488   {
00489     if (!dbh->tr_cnt)
00490       return statusMake(TRANSACTION_NEEDED, "protectionModify");
00491     return ESM_protectionModify((DbHandle *)dbh, desc, oid);
00492   }
00493 
00494   Status
00495   protectionGetByName(DbHandle const *dbh,
00496                       char const *name,
00497                       ProtectionDescription **desc,
00498                       Oid *oid)
00499   {
00500     if (!dbh->tr_cnt)
00501       return statusMake(TRANSACTION_NEEDED, "protectionGetByName");
00502     return ESM_protectionGetByName((DbHandle *)dbh, name, desc, oid);
00503   }
00504 
00505   Status
00506   protectionGetByOid(DbHandle const *dbh,
00507                      Oid const *oid,
00508                      ProtectionDescription **desc)
00509   { 
00510     if (!dbh->tr_cnt)
00511       return statusMake(TRANSACTION_NEEDED, "protectionGetByOid");
00512     return ESM_protectionGetByOid((DbHandle *)dbh, oid, desc);
00513   }
00514 
00515   Status
00516   protectionListGet(DbHandle const *dbh,
00517                     Oid **oid, ProtectionDescription ***desc,
00518                     unsigned int *nprot)
00519   {
00520     if (!dbh->tr_cnt)
00521       return statusMake(TRANSACTION_NEEDED, "protectionListGet");
00522     return ESM_protectionListGet((DbHandle *)dbh, oid, desc, nprot);
00523   }
00524 
00525   Status
00526   dbProtectionAdd(DbHandle const *dbh,
00527                   DbProtectionDescription const *desc, int nprot)
00528   {
00529     if (!dbh->tr_cnt)
00530       return statusMake(TRANSACTION_NEEDED, "dbProtectionAdd");
00531     return ESM_dbProtectionAdd((DbHandle *)dbh, desc, nprot);
00532   }
00533 
00534   Status
00535   dbProtectionGet(DbHandle const *dbh,
00536                   DbProtectionDescription **desc, unsigned int *nprot)
00537   {
00538     if (!dbh->tr_cnt)
00539       return statusMake(TRANSACTION_NEEDED, "dbProtectionGet");
00540     return ESM_dbProtectionGet((DbHandle *)dbh, desc, nprot);
00541   }
00542 
00543   Status
00544   objectProtectionSet(DbHandle const *dbh, Oid const *const oid,
00545                       Oid const *const protoid)
00546   {
00547     if (!dbh->tr_cnt)
00548       return statusMake(TRANSACTION_NEEDED, "objectProtectionSet");
00549     return ESM_objectProtectionSet((DbHandle *)dbh, oid, protoid, OPDefault);
00550   }
00551 
00552   Status
00553   objectProtectionGet(DbHandle const *dbh, Oid const *const oid,
00554                       Oid *protoid)
00555   {
00556     if (!dbh->tr_cnt)
00557       return statusMake(TRANSACTION_NEEDED, "objectProtectionGet");
00558     return ESM_objectProtectionGet((DbHandle *)dbh, oid, protoid);
00559   }
00560 
00561   Status
00562   datCreate(DbHandle const *dbh, const char *file, const char *name,
00563             unsigned long long maxsize, MapType mtype, unsigned int sizeslot,
00564             DatType dtype, mode_t file_mask, const char *file_group)
00565   {
00566     if (!dbh->tr_cnt)
00567       return statusMake(TRANSACTION_NEEDED, "datCreate");
00568     return ESM_datCreate((DbHandle *)dbh, file, name, maxsize, mtype, sizeslot, dtype, file_mask, file_group);
00569   }
00570 
00571 
00572   Status
00573   datMove(DbHandle const *dbh, const char *datfile, const char *newdatfile)
00574   {
00575     if (!dbh->tr_cnt)
00576       return statusMake(TRANSACTION_NEEDED, "datMove");
00577     return ESM_datMove((DbHandle *)dbh, datfile, newdatfile, False);
00578   }
00579 
00580   Status
00581   datResize(DbHandle const *dbh, const char *datfile,
00582             unsigned long long newmaxsize)
00583   {
00584     if (!dbh->tr_cnt)
00585       return statusMake(TRANSACTION_NEEDED, "datResize");
00586     return ESM_datResize((DbHandle *)dbh, datfile, newmaxsize);
00587   }
00588 
00589   Status
00590   datDelete(DbHandle const *dbh, const char *datfile)
00591   {
00592     if (!dbh->tr_cnt)
00593       return statusMake(TRANSACTION_NEEDED, "datDelete");
00594     return ESM_datDelete((DbHandle *)dbh, datfile, False);
00595   }
00596 
00597   Status
00598   datDefragment(DbHandle const *dbh, const char *datfile, mode_t file_mask, const char *file_group)
00599   {
00600     if (!dbh->tr_cnt)
00601       return statusMake(TRANSACTION_NEEDED, "datDefragment");
00602     return ESM_datDefragment((DbHandle *)dbh, datfile, file_mask, file_group);
00603   }
00604 
00605   Status
00606   datCheck(DbHandle const *dbh, const char *datfile, short *datid,
00607            short *dspid)
00608   {
00609     return ESM_datCheck((DbHandle *)dbh, datfile, datid, dspid);
00610   }
00611 
00612   Status
00613   datResetCurSlot(DbHandle const *dbh, const char *datfile)
00614   {
00615     if (!dbh->tr_cnt)
00616       return statusMake(TRANSACTION_NEEDED, "datResetCurSlot");
00617     return ESM_datResetCurSlot((DbHandle *)dbh, datfile);
00618   }
00619 
00620   Status
00621   dspCheck(DbHandle const *dbh, const char *dataspace, short *dspid,
00622            short datid[], unsigned int *ndat)
00623   {
00624     return ESM_dspCheck((DbHandle *)dbh, dataspace, dspid, datid, ndat);
00625   }
00626 
00627   Status
00628   dspSetCurDat(DbHandle const *dbh, const char *dataspace, const char *datfile)
00629   {
00630     if (!dbh->tr_cnt)
00631       return statusMake(TRANSACTION_NEEDED, "dspSetCurDat");
00632     return ESM_dspSetCurDat((DbHandle *)dbh, dataspace, datfile);
00633   }
00634 
00635   Status
00636   dspGetCurDat(DbHandle const *dbh, const char *dataspace, short *datid)
00637   {
00638     return ESM_dspGetCurDat((DbHandle *)dbh, dataspace, datid);
00639   }
00640 
00641   Status
00642   dspSetDefault(DbHandle const *dbh, const char *dataspace)
00643   {
00644     if (!dbh->tr_cnt)
00645       return statusMake(TRANSACTION_NEEDED, "dspSetDefault");
00646     return ESM_dspSetDefault((DbHandle *)dbh, dataspace, False);
00647   }
00648 
00649   Status
00650   dspGetDefault(DbHandle const *dbh, short *dspid)
00651   {
00652     return ESM_dspGetDefault((DbHandle *)dbh, dspid);
00653   }
00654 
00655   Status
00656   datRename(DbHandle const *dbh, const char *datfile, const char *name)
00657   {
00658     if (!dbh->tr_cnt)
00659       return statusMake(TRANSACTION_NEEDED, "dspRename");
00660     return ESM_datRename((DbHandle *)dbh, datfile, name);
00661   }
00662 
00663   Status
00664   datGetInfo(DbHandle const *dbh, const char *datfile, DatafileInfo *info)
00665   {
00666     return ESM_datGetInfo((DbHandle *)dbh, datfile, info);
00667   }
00668 
00669   Status
00670   datGetDspid(DbHandle const *dbh, short datid, short *dspid)
00671   {
00672     return ESM_datGetDspid((DbHandle *)dbh, datid, dspid);
00673   }
00674 
00675   Status
00676   datMoveObjects(DbHandle const *dbh, const char *dat_src,
00677                  const char *dat_dest)
00678   {
00679     if (!dbh->tr_cnt)
00680       return statusMake(TRANSACTION_NEEDED, "datMoveObjects");
00681     return ESM_datMoveObjects((DbHandle *)dbh, dat_src, dat_dest);
00682   }
00683 
00684   Status
00685   dspCreate(DbHandle const *dbh, const char *dataspace,
00686             const char **datfiles, unsigned int datfile_cnt)
00687   {
00688     if (!dbh->tr_cnt)
00689       return statusMake(TRANSACTION_NEEDED, "dspCreate");
00690     return ESM_dspCreate((DbHandle *)dbh, dataspace, datfiles, datfile_cnt, False);
00691   }
00692 
00693   Status
00694   dspUpdate(DbHandle const *dbh, const char *dataspace,
00695             const char **datfiles, unsigned int datfile_cnt,
00696             short flags, short orphan_dspid)
00697   {
00698     if (!dbh->tr_cnt)
00699       return statusMake(TRANSACTION_NEEDED, "dspUpdate");
00700     return ESM_dspUpdate((DbHandle *)dbh, dataspace, datfiles, datfile_cnt,
00701                          flags, orphan_dspid);
00702   }
00703 
00704   Status
00705   dspDelete(DbHandle const *dbh, const char *dataspace)
00706   {
00707     if (!dbh->tr_cnt)
00708       return statusMake(TRANSACTION_NEEDED, "dspDelete");
00709     return ESM_dspDelete((DbHandle *)dbh, dataspace);
00710   }
00711 
00712   Status
00713   dspRename(DbHandle const *dbh, const char *dataspace,
00714             const char *dataspace_new)
00715   {
00716     if (!dbh->tr_cnt)
00717       return statusMake(TRANSACTION_NEEDED, "dspRename");
00718     return ESM_dspRename((DbHandle *)dbh, dataspace, dataspace_new);
00719   }
00720 
00721   Status
00722   registerStart(DbHandle const *dbh, unsigned reg_mask)
00723   {
00724     return ESM_registerStart((DbHandle *)dbh, reg_mask);
00725   }
00726 
00727   Status
00728   registerClear(DbHandle const *dbh)
00729   {
00730     return ESM_registerClear((DbHandle *)dbh);
00731   }
00732 
00733   Status
00734   registerEnd(DbHandle const *dbh)
00735   {
00736     return ESM_registerEnd((DbHandle *)dbh);
00737   }
00738 
00739   Status
00740   registerGet(DbHandle const *dbh, Register **preg)
00741   {
00742     return ESM_registerGet((DbHandle *)dbh, preg);
00743   }
00744 
00745 }