eyedb: syscls.odl Source File

00001 /* 
00002    EyeDB Object Database Management System
00003    Copyright (C) 1994-1999,2004,2005 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 
00025 //
00026 //
00027 // syscls.odl
00028 //
00029 // All system classes which are part of eyedb kernel, but that are not
00030 // defined in the native mode:
00031 //
00032 //  executable (method, trigger)
00033 //  constraint (key, notnull, checkconstraint)
00034 //  class variables
00035 //  index
00036 //  protection
00037 //
00038 //
00039 
00040 #define INDEX
00041 
00042 class attribute_component [AttributeComponent] {
00043   string name;
00044   string attrpath;
00045   class *class_owner;
00046   bool #propagate;
00047   %C++{
00048     virtual Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00049     Status checkUnique(const char *, const char *);
00050     Status find(Database *db, const Class *cls,
00051                 AttributeComponent *&);
00052     virtual AttributeComponent *xclone(Database *, const Class *);
00053     std::string makeAttrpath(const Class *cls);
00054     void userInitialize();
00055     void userCopy(const Object &);
00056     void userGarbage();
00057     virtual int getInd() const;
00058     %}
00059 };
00060 
00061 class attribute_component_set [AttributeComponentSet] {
00062   string attrname;
00063   set<attribute_component *> comps;
00064   class *class_owner;
00065   %C++{
00066     void userInitialize();
00067     void userCopy(const Object &);
00068     void userGarbage();
00069 
00070     Status find(const char *, Index *&);
00071     Status find(const char *, NotNullConstraint *&);
00072     Status find(const char *, UniqueConstraint *&);
00073     Status find(const char *, CollAttrImpl *&);
00074     Status find(const char *, CardinalityConstraint_Test *&);
00075     Status getAttrComponents(const Class *, LinkedList &);
00076     Status hasIndex(bool &has_index, std::string &idx_str);
00077 
00078   private:
00079     struct Cache {
00080       unsigned int comp_count;
00081       unsigned int comp_alloc;
00082       struct Comp {
00083         char *attrpath;
00084         AttributeComponent *comp;
00085         Comp();
00086         ~Comp();
00087       } *comps;
00088       Cache();
00089       void add(AttributeComponent *);
00090       void getComponents(const char *, int, LinkedList &);
00091       AttributeComponent *find(const char *attrpath);
00092       ~Cache();
00093     };
00094 
00095     Status makeCache();
00096     void invalidateCache();
00097 
00098     Cache *index_cache, *notnull_cache, *unique_cache, *card_cache, *collimpl_cache;
00099     friend class Attribute;
00100     %}
00101 };
00102 
00103 // ---------------------------------------------------------------------------
00104 //
00105 // Class & Agregat Components
00106 //
00107 // ---------------------------------------------------------------------------
00108 
00109 class class_component [ClassComponent] {
00110   class *class_owner;
00111   string name;
00112 
00113   %C++{
00114     virtual Status check(Class *) const;
00115     virtual Bool   isInherit() const;
00116     virtual Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00117     virtual int getInd() const;
00118     virtual Status make(Class *);
00119     virtual Status realize(const RecMode* = NoRecurs);
00120     virtual Status remove(const RecMode* = NoRecurs);
00121     virtual Status realize_for_update();
00122     virtual Status remove_for_update();
00123     %}
00124 };
00125 
00126 class agregat_class_component [AgregatClassComponent] extends class_component {
00127 };
00128 
00129 class class_variable [ClassVariable]  extends class_component {
00130   string vname;
00131   object *val;
00132 
00133   %C++{
00134     Status check(Class *) const;
00135     Bool   isInherit() const;
00136     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00137     int getInd() const;
00138     Status m_trace(FILE *, int, unsigned int, const RecMode *);
00139     %}
00140 };
00141 
00142 // ---------------------------------------------------------------------------
00143 //
00144 // Indexes
00145 //
00146 // ---------------------------------------------------------------------------
00147 
00148 class #index [Index] extends attribute_component {
00149   oid idx_oid;
00150   short dspid;
00151   bool is_string;
00152   int impl_hints[];
00153 
00154   %C++{
00155     Index(Database *, const char *, const char *);
00156     virtual   Status realize(const RecMode* = NoRecurs);
00157     virtual   Status remove(const RecMode* = NoRecurs);
00158     virtual   Status s_trace(FILE *, Bool, unsigned int flags = 0) const;
00159     Idx    *idx;
00160     Status makeDataspace(Database *db, const Dataspace *&) const;
00161 
00162     void userInitialize();
00163     void userCopy(const Object &);
00164     void userGarbage();
00165     Status move(const Dataspace *) const;
00166     short get_dspid() const;
00167     Bool compareHints(Index *idx);
00168     int getInd() const;
00169 
00170     // utility methods
00171     Status getCount(unsigned int &count);
00172     Status getStats(std::string &, Bool dspImpl = True,
00173                     Bool full = False, const char *indent = "");
00174     Status getStats(IndexStats *&stats);
00175     Status simulate(const IndexImpl &, std::string &,
00176                     Bool dspImpl = True, Bool full = False,
00177                     const char *indent = "");
00178     Status simulate(const IndexImpl &, IndexStats *&stats);
00179 
00180     Status reimplement(const IndexImpl &, Index *&);
00181     virtual Status setImplementation(const IndexImpl *) {return Success;}
00182     virtual Status getImplementation(IndexImpl *&, Bool remote = False) const {return 0;}
00183     Status getDefaultDataspace(const Dataspace *&) const;
00184     Status setDefaultDataspace(const Dataspace *);
00185     Status getObjectLocations(ObjectLocationArray &);
00186     virtual Status report(eyedbsm::DbHandle *sedbh, const Oid &idxoid);
00187     %}
00188 };
00189 
00190 class #hashindex [HashIndex] extends #index {
00191   be_method_C *hash_method;
00192   int key_count;
00193 
00194   %C++{
00195     HashIndex(Database *, Class *, const char *attrpath,
00196               Bool propagate, Bool is_string,
00197               const Dataspace * = 0, int key_count = 0,
00198               BEMethod_C * = 0,
00199               const int *impl_hints = 0, int impl_hints_cnt = 0);
00200     HashIndex(Database *, Class *, const char *attrpath,
00201               Bool propagate, Bool is_string,
00202               const IndexImpl *idximpl);
00203     static Status make(Database *, Class *, const char *attrpath,
00204                        Bool propagate, Bool is_string,
00205                        const char *hints, HashIndex *&);
00206     Status setImplementation(const IndexImpl *);
00207     Status getImplementation(IndexImpl *&, Bool remote = False) const;
00208     virtual AttributeComponent *xclone(Database *, const Class *);
00209     Status check(Class *) const;
00210     Status make(Class *);
00211     Status realize(const RecMode* = NoRecurs);
00212     Status remove(const RecMode* = NoRecurs);
00213     Status s_trace(FILE *, Bool, unsigned int flags = 0) const;
00214     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00215     Bool compareHashMethod(HashIndex *idx);
00216     const char *genName() const;
00217     virtual Status report(eyedbsm::DbHandle *sedbh, const Oid &idxoid);
00218     %}
00219 };
00220 
00221 class #btreeindex [BTreeIndex] extends #index {
00222   int degree;
00223 
00224   %C++{
00225     BTreeIndex(Database *, Class *,
00226                const char *attrpath, Bool propagate, Bool is_string,
00227                const Dataspace * = 0, int degree = 0,
00228                const int *impl_hints = 0, int impl_hints_cnt = 0);
00229     BTreeIndex(Database *, Class *,  const char *pathattr,
00230                Bool propagate, Bool is_string,
00231                const IndexImpl *idximpl);
00232     static Status make(Database *, Class *, const char *attrpath,
00233                        Bool propagate, Bool is_string,
00234                        const char *hints, BTreeIndex *&);
00235     Status setImplementation(const IndexImpl *);
00236     Status getImplementation(IndexImpl *&, Bool remote = False) const;
00237     virtual AttributeComponent *xclone(Database *, const Class *);
00238     Status check(Class *) const;
00239     Status realize(const RecMode* = NoRecurs);
00240     Status remove(const RecMode* = NoRecurs);
00241     Status s_trace(FILE *, Bool, unsigned int flags = 0) const;
00242     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00243     const char *genName() const; 
00244     virtual Status report(eyedbsm::DbHandle *sedbh, const Oid &idxoid);
00245     %}
00246 };
00247 
00248 // ---------------------------------------------------------------------------
00249 //
00250 // Collection implementation
00251 //
00252 // ---------------------------------------------------------------------------
00253 
00254 enum index_type [IndexType] {
00255   HASH_INDEX_TYPE [HashIndexType] = 0x20,
00256     BTREE_INDEX_TYPE [BTreeIndexType] = 0x40
00257     };
00258 
00259 class collection_attribute_implementation [CollAttrImpl] extends attribute_component {
00260   int impl_type;
00261   short dspid;
00262   int key_count_or_degree;
00263   be_method_C *hash_method;
00264   int impl_hints[];
00265 
00266   %C++{
00267 
00268     CollAttrImpl(Database *, Class *, const char *attrpath,
00269                  Bool propagate, const Dataspace * = 0,
00270                  CollImpl::Type impl_type = CollImpl::HashIndex,
00271                  int key_count_or_degree = 0,
00272                  BEMethod_C * = 0,
00273                  const int *impl_hints = 0, int impl_hints_cnt = 0);
00274     CollAttrImpl(Database *, Class *, const char *attrpath,
00275                  Bool propagate, const IndexImpl *idximpl);
00276 
00277     Status makeDataspace(Database *db, const Dataspace *&) const;
00278     static Status make(Database *, Class *, const char *attrpath,
00279                        Bool propagate,
00280                        CollImpl::Type impl_type, const char *hints,
00281                        CollAttrImpl *&);
00282     Status getImplementation(Database *, const CollImpl *&);
00283     virtual AttributeComponent *xclone(Database *, const Class *);
00284     Status realize(const RecMode* = NoRecurs);
00285     Status remove(const RecMode* = NoRecurs);
00286     Status s_trace(FILE *, Bool, unsigned int flags = 0) const;
00287     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00288     const char *genName() const;
00289     int getInd() const;
00290 
00291     void userInitialize();
00292     void userCopy(const Object &);
00293     void userGarbage();
00294 
00295     const Dataspace *dsp;
00296     CollImpl *collimpl;
00297     %}
00298 };
00299 
00300 // ---------------------------------------------------------------------------
00301 //
00302 // Executables
00303 //
00304 // ---------------------------------------------------------------------------
00305 
00306 enum executable_lang [ExecutableLang] {
00307   C_LANG [C_LANG] = 0x1,
00308     OQL_LANG [OQL_LANG] = 0x2,
00309     SYSTEM_EXEC [SYSTEM_EXEC] = 0x100
00310     };
00311 
00312 enum argtype_type [ArgType_Type] {
00313   ANY_TYPE [ANY_TYPE] = 0,
00314     VOID_TYPE [VOID_TYPE],
00315     INT16_TYPE [INT16_TYPE],
00316     INT32_TYPE [INT32_TYPE],
00317     INT64_TYPE [INT64_TYPE],
00318     STRING_TYPE [STRING_TYPE],
00319     CHAR_TYPE [CHAR_TYPE],
00320     FLOAT_TYPE [FLOAT_TYPE],
00321     OID_TYPE [OID_TYPE],
00322     OBJ_TYPE [OBJ_TYPE],
00323     RAW_TYPE [RAW_TYPE],
00324     BYTE_TYPE [BYTE_TYPE],
00325     ARRAY_TYPE [ARRAY_TYPE] = 0x0100,
00326     IN_ARG_TYPE [IN_ARG_TYPE] = 0x1000,
00327     OUT_ARG_TYPE [OUT_ARG_TYPE] = 0x2000,
00328     INOUT_ARG_TYPE [INOUT_ARG_TYPE] = 0x3000 // IN_ARG_TYPE | OUT_ARG_TYPE
00329     };
00330 
00331 class argtype [ArgType] {
00332   argtype_type #type;
00333   string clname;
00334   %C++{
00335     Bool operator==(const ArgType &) const;
00336 
00337     Bool operator!=(const ArgType &) const;
00338     static ArgType *make(Schema *m, const char *s);
00339     static int getBasicType(const char *s);
00340     void declare(FILE *, Schema *, const char *name);
00341     void init(FILE *, Schema *, const char *prefix, const char *name,
00342               const char *indent);
00343     void ret(FILE *, Schema *, const char *prefix, const char *name);
00344     const char *getCType(Schema *) const;
00345     void getCPrefix(FILE *fd, Schema *, const char *prefix,
00346                     const char *name, Bool fullcast) const;
00347     %}
00348 };
00349 
00350 enum executable_localisation [ExecutableLocalisation] {
00351   BACKEND [BACKEND] = 1,
00352     FRONTEND [FRONTEND],
00353     STATIC_EXEC [STATIC_EXEC] = 0x100
00354     };
00355 
00356 enum executable_type [ExecutableType] {
00357   METHOD_C_TYPE [METHOD_C_TYPE]       = 0x02,
00358     METHOD_OQL_TYPE [METHOD_OQL_TYPE]   = 0x12,
00359     TRIGGER_C_TYPE [TRIGGER_C_TYPE]     = 0x08,
00360     TRIGGER_OQL_TYPE [TRIGGER_OQL_TYPE] = 0x18
00361     };
00362 
00363 #define TriggerBEFORE 0x01
00364 #define TriggerAFTER  0x02
00365 
00366 #define TriggerCREATE 0x10
00367 #define TriggerUPDATE 0x20
00368 #define TriggerLOAD   0x40
00369 #define TriggerREMOVE 0x80
00370 
00371 #define MK(X,W) ((X)|(W))
00372 
00373 enum trigger_type [TriggerType] {
00374   TRIGGER_CREATE_BEFORE [TriggerCREATE_BEFORE]
00375     = MK(TriggerCREATE, TriggerBEFORE),
00376 
00377     TRIGGER_CREATE_AFTER [TriggerCREATE_AFTER]
00378     = MK(TriggerCREATE, TriggerAFTER),
00379 
00380     TRIGGER_UPDATE_BEFORE [TriggerUPDATE_BEFORE]
00381     = MK(TriggerUPDATE, TriggerBEFORE),
00382 
00383     TRIGGER_UPDATE_AFTER [TriggerUPDATE_AFTER]
00384     = MK(TriggerUPDATE, TriggerAFTER),
00385 
00386     TRIGGER_LOAD_BEFORE [TriggerLOAD_BEFORE]  
00387     = MK(TriggerLOAD,   TriggerBEFORE),
00388 
00389     TRIGGER_LOAD_AFTER [TriggerLOAD_AFTER]   
00390     = MK(TriggerLOAD,   TriggerAFTER),
00391 
00392     TRIGGER_REMOVE_BEFORE [TriggerREMOVE_BEFORE]
00393     = MK(TriggerREMOVE, TriggerBEFORE),
00394 
00395     TRIGGER_REMOVE_AFTER [TriggerREMOVE_AFTER] 
00396     = MK(TriggerREMOVE, TriggerAFTER)
00397     };
00398 
00399 class signature [Signature] {
00400   argtype rettype;
00401   int nargs;
00402   argtype types [];
00403   %C++{
00404     Bool operator ==(const Signature &) const;
00405     Bool operator !=(const Signature &) const;
00406     const char *getArg(int i);
00407     static const char *getPrefix(const char *prefix, int i);
00408     static Bool isVoid(const ArgType *type);
00409     void listArgs(FILE *, Schema *);
00410     void declArgs(FILE *, Schema *);
00411     void initArgs(FILE *, Schema *, const char *prefix, const char *preret,
00412                   const char *indent);
00413     void setArgs(FILE *, Schema *, int type, const char *prefix,
00414                  const char *preret, const char *indent);
00415     void retArgs(FILE *, Schema *, const char *prefix, const char *preret,
00416                  const char *indent);
00417     %}
00418 };
00419  
00420 class executable [Executable] {
00421   string exname; /* executable name, limited to 64 chars */
00422   executable_lang lang;
00423   executable_localisation loc;
00424   signature sign;
00425   string intname; /* internal name including signature */
00426   string extref_body; /* external reference or body */
00427 
00428   %C++{
00429     void initExec(const char *exname,
00430                   ExecutableLang lang,
00431                   Bool isSystem,
00432                   ExecutableLocalisation loc,
00433                   Signature *sign, Class * = 0);
00434     static const char *makeInternalName(const char *exname,
00435                                         const Signature *sign,
00436                                         Bool isClassMethod,
00437                                         const char *clname = 0);
00438     const char *_getPrototype(const Class *, Bool scope) const;
00439     static const char *makeExtRef(const char *extref);
00440     static const char *getSOTag();
00441     static const char *getSOFile(const char *extref);
00442     static void *_dlopen(const char *extref);
00443     int isStaticExec() const;
00444     void *dl;
00445     void userInitialize();
00446     void userCopy(const Object &);
00447     virtual Status execCheck();
00448     Status checkRealize(const char *, const char *, void **);
00449     static Status checkRealize(const char *extref, const char *intname,
00450                                void **pdl, void **pcsym);
00451     %}
00452 
00453   constraint <notnull> on exname;
00454 };
00455 
00456 class agregat_class_executable [AgregatClassExecutable] extends agregat_class_component {
00457   executable ex; // because no multiple inheritance
00458 
00459 #ifdef INDEX
00460   index <propagate=off> on ex.exname;
00461   index <propagate=off> on ex.intname;
00462 #endif
00463 };
00464 
00465 class #method [Method] extends agregat_class_executable {
00466   %C++{
00467     virtual Status applyTo(Database *, Object *, ArgArray &,
00468                            Argument &retarg, Bool checkArgs);
00469     Status realize(const RecMode* = NoRecurs);
00470     Status remove(const RecMode* = NoRecurs);
00471 
00472     static Status get(Database *, Class *, const char *name,
00473                       const Signature *, Bool isClassMethod,
00474                       Method * &);
00475 
00476     static Status getSignature(Database *, Class *,
00477                                const char *sign_str, Signature *&,
00478                                char *&fname);
00479 
00480     static Status get(Database *, Class *,
00481                       const char *sign_str, Bool isClassMethod,
00482                       Method * &);
00483 
00484     const char *getPrototype(Bool scope = True) const;
00485 
00486     Status check(Class *) const;
00487     Bool   isInherit() const;
00488     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00489     int getInd() const;
00490     virtual Status execCheck();
00491     %}
00492 
00493 #ifdef INDEX
00494   index <propagate=off> on ex.exname;
00495   index <propagate=off> on ex.intname;
00496 #endif
00497 };
00498 
00499 class fe_method [FEMethod] extends #method {
00500 #ifdef INDEX
00501   index <propagate=off> on ex.exname;
00502   index <propagate=off> on ex.intname;
00503 #endif
00504 };
00505 
00506 class fe_method_C [FEMethod_C] extends fe_method {
00507   %C++{
00508     Status (*csym)(Database *, FEMethod_C *, Object *,
00509                    ArgArray &array, Argument &retarg);
00510     FEMethod_C(Database *, Class *, const char *name,
00511                Signature *, Bool isClassMethod,
00512                Bool isSystem, const char *extref);
00513     Status execCheck();
00514     Status applyTo(Database *, Object *, ArgArray &, Argument &retarg, Bool checkArgs);
00515     void userInitialize();
00516     void userCopy(const Object &);
00517     %}
00518 #ifdef INDEX
00519   index <propagate=off> on ex.exname;
00520   index <propagate=off> on ex.intname;
00521 #endif
00522 };
00523 
00524 class be_method [BEMethod] extends #method {
00525 #ifdef INDEX
00526   index <propagate=off> on ex.exname;
00527   index <propagate=off> on ex.intname;
00528 #endif
00529 };
00530 
00531 class be_method_C [BEMethod_C] extends be_method {
00532   %C++{
00533     Status (*csym)(Database *, BEMethod *, Object *,
00534                    ArgArray &array, Argument &retarg);
00535     BEMethod_C(Database *, Class *, const char *name,
00536                Signature *, Bool isClassMethod,
00537                Bool isSystem, const char *extref);
00538     Status execCheck();
00539     Status applyTo(Database *, Object *, ArgArray &, Argument &retarg, Bool checkArgs);
00540     %}
00541 #ifdef INDEX
00542   index <propagate=off> on ex.exname;
00543   index <propagate=off> on ex.intname;
00544 #endif
00545 };
00546 
00547 class be_method_OQL [BEMethod_OQL] extends be_method {
00548 
00549   %C++{
00550     BEMethod_OQL(Database *, Class *, const char *name,
00551                  Signature *, Bool isClassMethod,
00552                  Bool isSystem, const char *body);
00553 
00554     Status execCheck();
00555     Status setBody(const char *);
00556     Status applyTo(Database *, Object *, ArgArray &,
00557                    Argument &retarg, Bool checkArgs);
00558 
00559     static std::string makeExtrefBody(const Class *cls, const char *oql,
00560                                       const char *fname,
00561                                       char *typnames[],
00562                                       char *varnames[],
00563                                       unsigned int param_cnt,
00564                                       std::string &oqlConstruct);
00565     Status runtimeInit();
00566 
00567     Bool isRTInitialized;
00568     char **varnames;
00569     int param_cnt;
00570     char *funcname;
00571     char *body;
00572     char *fullBody;
00573     char *tmpbuf;
00574     void *entry;
00575 
00576     void userInitialize();
00577     void userGarbage();
00578     void userCopy(const Object &);
00579     %}
00580 #ifdef INDEX
00581   index <propagate=off> on ex.exname;
00582   index <propagate=off> on ex.intname;
00583 #endif
00584 };
00585 
00586 class #trigger [Trigger] extends agregat_class_executable {
00587   trigger_type #type;
00588   int light;
00589   char suffix[16];
00590   %C++{
00591     Trigger(Database *, Class *, TriggerType,
00592             ExecutableLang, Bool isSystem, const char *suffix,
00593             Bool light, const char *extref);
00594     Status (*csym)(TriggerType, Database *, const Oid &,
00595                    Object *);
00596     Status apply(const Oid &, Object *);
00597     Status realize(const RecMode* = NoRecurs);
00598     Status remove(const RecMode* = NoRecurs);
00599     const char *getPrototype(Bool scope = True) const;
00600     const char *getCSym() const;
00601     static const char *getStrTriggerType(TriggerType);
00602     Bool   isInherit() const;
00603     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00604     int getInd() const;
00605 
00606     static std::string makeExtrefBody(const Class *cls, const char *oql,
00607                                       const char *fname,
00608                                       std::string &oqlConstruct);
00609     Status runtimeInit();
00610 
00611     Bool isRTInitialized;
00612     char *funcname;
00613     char *body;
00614     char *fullBody;
00615     char *tmpbuf;
00616     void *entry;
00617 
00618     void userInitialize();
00619     void userGarbage();
00620     void userCopy(const Object &);
00621     %}
00622 
00623 #ifdef INDEX
00624   index <propagate=off> on ex.exname;
00625   index <propagate=off> on ex.intname;
00626 #endif
00627 };
00628 
00629 // ---------------------------------------------------------------------------
00630 //
00631 // Constraint Classes
00632 //
00633 // ---------------------------------------------------------------------------
00634 
00635 class unique_constraint [UniqueConstraint] extends attribute_component {
00636   %C++{
00637     UniqueConstraint(Database *, Class *, const char *attrpath,
00638                      Bool propagate);
00639     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00640     Status realize(const RecMode* = NoRecurs);
00641     Status remove(const RecMode* = NoRecurs);
00642     virtual AttributeComponent *xclone(Database *, const Class *);
00643     const char *genName() const; 
00644     int getInd() const;
00645     %}
00646 };
00647 
00648 class notnull_constraint [NotNullConstraint] extends attribute_component {
00649   %C++{
00650     NotNullConstraint(Database *, Class *, const char *attrpath,
00651                       Bool propagate);
00652     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00653     Status realize(const RecMode* = NoRecurs);
00654     Status remove(const RecMode* = NoRecurs);
00655     virtual AttributeComponent *xclone(Database *, const Class *);
00656     const char *genName() const; 
00657     int getInd() const;
00658     %}
00659 };
00660 
00661 class cardinality_description [CardinalityDescription] {
00662   int bottom;
00663   int bottom_excl;
00664   int top;
00665   int top_excl;
00666   %C++{
00667     const char *getString(Bool = True) const;
00668     Bool compare(CardinalityDescription *);
00669     %}
00670 };
00671 
00672 class cardinality_constraint [CardinalityConstraint] extends agregat_class_component {
00673   string attrname;
00674   cardinality_description card_desc;
00675 
00676   %C++{
00677     CardinalityConstraint(Database *, Class *,
00678                           const char *attrname, int, int, int, int);
00679     Status check(Class *) const;
00680     const char *genName() const;
00681     Bool   isInherit() const;
00682     Status make(Class *);
00683     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00684     int getInd() const;
00685     static int maxint;
00686     %}
00687 };
00688 
00689 // ---------------------------------------------------------------------------
00690 //
00691 // Classes for component propagation tests
00692 //
00693 // _Test suffix will disapear
00694 //
00695 // ---------------------------------------------------------------------------
00696 
00697 class cardinality_constraint_test [CardinalityConstraint_Test] extends attribute_component {
00698   cardinality_description card_desc;
00699 
00700   %C++{
00701     CardinalityConstraint_Test(Database *, Class *,
00702                                const char *attrpath,
00703                                int, int, int, int);
00704     Status realize(const RecMode* = NoRecurs);
00705     Status remove(const RecMode* = NoRecurs);
00706     const char *genName() const;
00707     Status m_trace(FILE *, int, unsigned int, const RecMode *) const;
00708     static int maxint;
00709     int getInd() const;
00710     %}
00711 };
00712 
00713 // ---------------------------------------------------------------------------
00714 //
00715 // Protection Classes
00716 //
00717 // ---------------------------------------------------------------------------
00718 
00719 enum protection_mode [ProtectionMode] {
00720   PROT_READ [ProtRead] = 0x100,
00721     PROT_RW [ProtRW] = 0x101
00722     };
00723       
00724 class protection_user [ProtectionUser] {
00725   object *user;
00726   protection_mode mode;
00727 };
00728 
00729 class protection [Protection] {
00730   string name;
00731   protection_user pusers[];
00732   oid poid;
00733 
00734   %C++{
00735     Status realize(const RecMode* = NoRecurs);
00736     Status remove(const RecMode* = NoRecurs);
00737     %}
00738 };
00739 
00740 // ---------------------------------------------------------------------------
00741 //
00742 // Internal Classes
00743 //
00744 // ---------------------------------------------------------------------------
00745 
00746 class unreadable_object [UnreadableObject] {
00747   %C++{
00748     Status trace_realize(FILE*, int, unsigned int, const RecMode *) const;
00749     static Bool isUnreadableObject(const Object *);
00750     static Bool isUnreadableObject(const Class *);
00751     %}
00752 };
00753 
00754 // ---------------------------------------------------------------------------
00755 //
00756 // Schema Flexibility Classes
00757 //
00758 // ---------------------------------------------------------------------------
00759 
00760 enum class_update_type [ClassUpdateType] {
00761   ADD_ATTR [ADD_ATTR],
00762     RMV_ATTR [RMV_ATTR],
00763     CNV_ATTR [CNV_ATTR],
00764     MIG_ATTR [MIG_ATTR],
00765     RMV_CLASS [RMV_CLASS]
00766     };
00767 
00768 enum attribute_convert_type [AttributeConvertType] {
00769   // numeric conversions
00770   INT16_TO_INT16 [INT16_TO_INT16],
00771     INT16_TO_INT32 [INT16_TO_INT32],
00772     INT16_TO_INT64 [INT16_TO_INT64],
00773     INT16_TO_FLOAT [INT16_TO_FLOAT],
00774     INT16_TO_BYTE [INT16_TO_BYTE],
00775     INT16_TO_CHAR [INT16_TO_CHAR],
00776     INT16_TO_ENUM [INT16_TO_ENUM],
00777 
00778     INT32_TO_INT32 [INT32_TO_INT32],
00779     INT32_TO_INT16 [INT32_TO_INT16],
00780     INT32_TO_INT64 [INT32_TO_INT64],
00781     INT32_TO_FLOAT [INT32_TO_FLOAT],
00782     INT32_TO_BYTE [INT32_TO_BYTE],
00783     INT32_TO_CHAR [INT32_TO_CHAR],
00784     INT32_TO_ENUM [INT32_TO_ENUM],
00785 
00786     INT64_TO_INT64 [INT64_TO_INT64],
00787     INT64_TO_INT16 [INT64_TO_INT16],
00788     INT64_TO_INT32 [INT64_TO_INT32],
00789     INT64_TO_FLOAT [INT64_TO_FLOAT],
00790     INT64_TO_BYTE [INT64_TO_BYTE],
00791     INT64_TO_CHAR [INT64_TO_CHAR],
00792     INT64_TO_ENUM [INT64_TO_ENUM],
00793   
00794     FLOAT_TO_FLOAT [FLOAT_TO_FLOAT],
00795     FLOAT_TO_INT16 [FLOAT_TO_INT16],
00796     FLOAT_TO_INT32 [FLOAT_TO_INT32],
00797     FLOAT_TO_INT64 [FLOAT_TO_INT64],
00798     FLOAT_TO_BYTE [FLOAT_TO_BYTE],
00799     FLOAT_TO_CHAR [FLOAT_TO_CHAR],
00800     FLOAT_TO_ENUM [FLOAT_TO_ENUM],
00801   
00802     CHAR_TO_CHAR [CHAR_TO_CHAR],
00803     CHAR_TO_INT16 [CHAR_TO_INT16],
00804     CHAR_TO_INT32 [CHAR_TO_INT32],
00805     CHAR_TO_INT64 [CHAR_TO_INT64],
00806     CHAR_TO_FLOAT [CHAR_TO_FLOAT],
00807     CHAR_TO_BYTE [CHAR_TO_BYTE],
00808     CHAR_TO_ENUM [CHAR_TO_ENUM],
00809   
00810     BYTE_TO_BYTE [BYTE_TO_BYTE],
00811     BYTE_TO_INT16 [BYTE_TO_INT16],
00812     BYTE_TO_INT32 [BYTE_TO_INT32],
00813     BYTE_TO_INT64 [BYTE_TO_INT64],
00814     BYTE_TO_FLOAT [BYTE_TO_FLOAT],
00815     BYTE_TO_CHAR [BYTE_TO_CHAR],
00816     BYTE_TO_ENUM [BYTE_TO_ENUM],
00817   
00818     ENUM_TO_ENUM [ENUM_TO_ENUM],
00819     ENUM_TO_INT16 [ENUM_TO_INT16],
00820     ENUM_TO_INT32 [ENUM_TO_INT32],
00821     ENUM_TO_INT64 [ENUM_TO_INT64],
00822     ENUM_TO_FLOAT [ENUM_TO_FLOAT],
00823     ENUM_TO_CHAR [ENUM_TO_CHAR],
00824     ENUM_TO_BYTE [ENUM_TO_BYTE],
00825 
00826     // string conversions
00827     CHAR_TO_STRING [CHAR_TO_STRING],
00828     STRING_TO_CHAR [STRING_TO_CHAR],
00829     INT16_TO_STRING [INT16_TO_STRING],
00830     STRING_TO_INT16 [STRING_TO_INT16],
00831     INT32_TO_STRING [INT32_TO_STRING],
00832     STRING_TO_INT32 [STRING_TO_INT32],
00833     INT64_TO_STRING [INT64_TO_STRING],
00834     STRING_TO_INT64 [STRING_TO_INT64],
00835     FLOAT_TO_STRING [FLOAT_TO_STRING],
00836     STRING_TO_FLOAT [STRING_TO_FLOAT],
00837     BYTE_TO_STRING [BYTE_TO_STRING],
00838     STRING_TO_BYTE [STRING_TO_BYTE],
00839 
00840     // collection conversions
00841     SET_TO_BAG [SET_TO_BAG],
00842     SET_TO_ARRAY [SET_TO_ARRAY],
00843     SET_TO_LIST [SET_TO_LIST],
00844   
00845     BAG_TO_SET [BAG_TO_SET],
00846     BAG_TO_ARRAY [BAG_TO_ARRAY],
00847     BAG_TO_LIST [BAG_TO_LIST],
00848   
00849     ARRAY_TO_BAG [ARRAY_TO_BAG],
00850     ARRAY_TO_SET [ARRAY_TO_SET],
00851     ARRAY_TO_LIST [ARRAY_TO_LIST],
00852   
00853     LIST_TO_BAG [LIST_TO_BAG],
00854     LIST_TO_ARRAY [LIST_TO_ARRAY],
00855     LIST_TO_SET [LIST_TO_SET],
00856   
00857     // class conversion
00858     CLASS_TO_CLASS [CLASS_TO_CLASS],
00859   
00860     // user conversions
00861     USER_CNV [USER_CNV],
00862 
00863     // no data conversion
00864     NIL_CNV [NIL_CNV]
00865     };
00866 
00867 class class_conversion [ClassConversion] {
00868 
00869   class_update_type updtype;
00870   attribute_convert_type cnvtype;
00871 
00872   // class name
00873   string clsname;
00874   // attribute name
00875   string attrname;
00876   // attribute num
00877   int attrnum;
00878   
00879   // old class
00880   oid oid_o; // entry point (indexed)
00881   // new class
00882   oid oid_n;
00883 
00884   // relative old class
00885   oid roid_o;
00886 
00887   // if updtype == CNV_ATTR, sync update ?
00888   int sync;
00889 
00890   // with_check, concerns:
00891   //   <coll>_TO_SET
00892   //   <numeric>_TO_ENUM
00893   int with_check;
00894 
00895   // conversion details:
00896   // concerning STRING_TO_STRING
00897   int src_dim;
00898   int dest_dim;
00899 
00900   // offset details
00901   int offset_o;
00902   int offset_n;
00903   int size_o;
00904   int size_n;
00905 
00906   BEMethod_C *cnv_mth;
00907 
00908   %C++{
00909     struct Context {
00910       const Class *cls;
00911       ObjectArray obj_arr;
00912       Context *next;
00913       Context();
00914       ~Context();
00915     };
00916 
00917     const Class *cls_;
00918     const Attribute *attr_;
00919     static Status getClass_(Database *, const Oid &ocloid,
00920                             const Class *&,
00921                             ClassConversion::Context *&,
00922                             Bool class_to_class = False);
00923     static Status convert(Database *, const ClassConversion::Context *,
00924                           Data in_idr, Size in_size);
00925     Status convert(Database *db, Data in_idr, Size &in_size);
00926     static Size computeSize(ClassConversion::Context *conv_ctx,
00927                             Size start_size);
00928     void computeSize(Size &cur_size);
00929 
00930     static void init();
00931     static void _release();
00932 
00933     void userInitialize();
00934     void userCopy(const Object &);
00935     void userGarbage();
00936     %}
00937 
00938 #ifdef INDEX
00939   index <propagate=off> on clsname;
00940   index <propagate=off> on oid_o;
00941   index <propagate=off> on oid_n;
00942 #endif
00943 };