optionblock: 'option' '{' oplist '}' ';'
{Tblproc:: OptBlockPrint ('',$_[ 3]);}
| 'Option' opitem ';'
{Tblproc:: OptBlockPrint ('',[$_[ 2 ]]);}
| 'Option' id '{' oplist '}' ';'
{Tblproc:: OptBlockPrint ($ _ [2 ],$_[ 4]);}
| 'Option' id opitem ';'
{Tblproc:: OptBlockPrint ($ _ [2 ],[$_[ 3 ]]);}
;
oplist:
opitem ';' {[$_[ 1]]}
| Opitem ';' oplist {push{$_[ 3]}, $ _ [1]; $ _ [3]}
;
opitem: id '=' literal
{[$_[ 1 ],@{$_[ 3]} [0], 0 ,@{$_[ 3]} [1]]}
| Id '=' id {[$_[ 1 ],$_[ 3], 1 ,'']}
;
#------------------------------------------------- --------
idxblock: 'idx' id idxitem ';'
{Tblproc:: IdxBlockPrint ($ _ [2 ],[$_[ 3 ]]);}
| 'Idx' id '{' idxitemlist '}' ';'
{Tblproc:: IdxBlockPrint ($ _ [2 ],$_[ 4]);}
;
idxitemlist: idxitem ';' {[$_[ 1]]}
| Idxitem ';' idxitemlist {unshift{$_[ 3 ]},$_[ 1]; $ _ [3]}
;
idxitem: idxmod1 id '(' flist1 ')'
{[0, $ _ [1 ],$_[ 2 ],$_[ 4 ],'']}
| Idxmod1 id '(' flist1 ')' '{*' rawcode '*}'
{[0, $ _ [1 ],$_[ 2 ],$_[ 4 ],$_[ 7]]}
| Idxmod2 id '(' flist2 ')' {[1, $ _ [1 ],$_[ 2 ],$_[ 4 ],'']}
| Idxmod2 id '(' flist2 ')' '{*' rawcode '*}'
{[1, $ _ [1 ],$_[ 2 ],$_[ 4 ],$_[ 7]]}
;
idxmod1: '.!'
| ':!'
| '%!'
;
idxmod2: '.'
| ':'
| '%'
;
flist1: id {[[$_[ 1 ],'']]}
| Id ',' flist1 {unshift
{$_[ 3 ]},[$_[ 1 ],''];$_[ 3]}
;
flist2: idxmod3 id {[[$_[ 2 ],$_[ 1]]]}
| Idxmod3 id ',' flist2 {unshift
{$_[ 4 ]},[$_[ 2 ],$_[ 1 ]];$_[ 4]}
;
idxmod3: '+'
| '-'
| '^'
;
#------------------------------------------------- --------
codeblock: code 'decl' '{*' rawcode '*}'
{Tblproc:: CodeBlockPrint ('hh', \ $ _ [4], 0);}
| Code 'tab' '{*' rawcode '*}'
{Tblproc:: CodeBlockPrint ('tab', \ $ _ [4], 0);}
| Code 'def' '{*' rawcode '*}'
{Tblproc:: CodeBlockPrint ('cc', \ $ _ [4], 0);}
| Code 'def' 'top' '{*' rawcode '*}'
{Tblproc:: CodeBlockPrint ('cc', \ $ _ [5], 1);}
| Code '{*' rawcode '*}'
{Tblproc:: CodeBlockPrint ('all', \ $ _ [3], 0);}
;
#------------------------------------------------- --------
enumblock: 'enum' id '{' enumlist '}' ';'
{Tblproc:: EnumBlockPrint ($ _ [2 ],$_[ 4]);}
| 'Enum' id ';'
{Tblproc:: EnumBlockPrint ($ _ [2 ],[]);}
;
enumlist: enumitem {[$_[ 1]]}
| Enumitem ',' enumlist {unshift{$_[ 3]}, $ _ [1]; $ _ [3]}
;
enumitem: id {[$_[ 1 ],'']}
| Id '=' num {[$_[ 1 ],$_[ 3]]}
;
#------------------------------------------------- --------
structblock: 'struct' id '{' structlist '}' ';'
{Tblproc:: StructBlockPrint ($ _ [2 ],$_[ 4]);}
;
structlist: structitem {[$_[ 1]]}
| Structitem structlist {unshift{$_[ 2]}, $ _ [1]; $ _ [2]}
;
structitem: id pnlistid ';'
{[$_[ 1 ],@{$_[ 2]} [0 ],@{$_[ 2]} [1]]}
;
#------------------------------------------------- --------
tableblock: tableforward
{Tblproc:: TableBlockPrint (@{$_[ 1]} [0 ],'',[],[]);}
| Tablehead ';'
{Tblproc:: TableBlockPrint (@{$_[ 1]} [0 ],@{$_[ 1]} [1 ],@{$_[ 1]} [2], []);}
| Tablehead tail ';'
{Tblproc:: TableBlockPrint (@{$_[ 1]} [0 ],@{$_[ 1]} [1 ],@{$_[ 1]} [2], $ _ [2]);}
;
tail: idxtailitem {$ _ [1]}
| Idxtailitem tail {unshift{$_[ 2 ]},$_[ 1 ];$_[ 2]}
| Optiontailitem
| Optiontailitem tail
;
tableforward: 'table' id ';' {[$_[ 2]]}
;
tablehead: 'table' memmodifid '{' memberlist '}'
{[@{$_[ 2]} [0 ],@{$_[ 2]} [1 ],$_[ 4]]}
;
memmodifid: id {[$_[ 1 ],'']}
| Memmodificator id {[$_[ 2 ],'$']}
;
memberlist: memberitem {[$_[ 1]]}
| Memberitem memberlist {unshift{$_[ 2]}, $ _ [1]; $ _ [2]}
;
memberitem: id pnlistid ';'
{[$_[ 1 ],@{$_[ 2]} [0 ],@{$_[ 2]} [1 ],[]]}
| Id pnlistid modificator1 ';'
{[$_[ 1 ],@{$_[ 2]} [0 ],@{$_[ 2]} [1 ],$_[ 3]]}
;
modificator1: idxmodificator {[$_[ 1],'']}
# | Idxmodificator memmodificator {[$_[ 1],'$','']}
| Idxmodificator '{*' rawcode '*}' {[$_[ 1], $ _ [3]]}
# | Idxmodificator memmodificator '{*' rawcode '*}' {[$_[ 1], '$', $ _ [4]]}
;
pnlistid: pnlist id {[$_[ 1], $ _ [2]]}
| Id {[[], $ _ [1]]}
;
pnlist: pointer {[$_[ 1 ],'']}
| Pointer array {[$_[ 1 ],$_[ 2]]}
| Array {['',$_[ 1]]}
;
pointer: '+'
| '-'
| '*'
;
array: '[' id ']' {$ _ [2]}
| '[' Num ']' {$ _ [2]}
;
idxmodificator: '.!'
| ':!'
| '%!'
| '. +'
| ': +'
| '% +'
| '.-'
| ': -'
| '% -'
| '. ^'
| ': ^'
| '% ^'
;
memmodificator: '$'
;
idxtailitem: 'idx' idxitem {[$_[ 2]]}
| 'Idx' '{' idxitemlist '}' {$ _ [3]}
;
optiontailitem: 'option' '{' oplist '}'
| 'Option' opitem
;
#------------------------------------------------- --------
%%
use tblproc;
Основними компонентами цієї граматики є:
· Option - елемент мови, що визначає налаштування до конкретної таблиці.
· Idx блок - це блок, який визначає параметри індексного таблиці.
· Table блок - блок, що визначає таблицю, її запису та індекси.
· Struct блок - блок, аналогічний table, з тією різницею, генерує лише визначення структур записів без визначення самої таблиці.
· Enum блок - визначення С + + енумераторов, використовуваних у визначенні таблиці.
· Code блок - блок сирого С + + коду встраімого безпосереднього в результуючий файл.
Транслятор складається з 3 основних частин лексики, семантики та пускового модуля, написаних на мові Perl.
Лексичний аналізатор створений з урахуванням цієї граматики і має наступний інтерфейс.
Prepare (array of lines); / / normal result == 0
token Next ();
Він підтримує також препроцессірованіе на рівні вкладень include.
Семантичний аналізатор складається з API, що викликаються як обробники подій (для інтерфейсу yapp вказуються у визначенні граматики).
Пусковий модуль є оболонкою для запуску синтаксичного аналізатора, з розбором вхідних параметрів
Формат:
1) HibaseCompiler.pl [-f ім'я файлу] [-p шлях до hibase] [-d каталог, куди приміщ. сген стаб]
2) program | HibaseCompiler.pl [-p шлях до hibase] [-d каталог, куди приміщ. сген стаб].
6.Прімер роботи програми
В якості прикладу розглянемо таке визначення бази даних
Tables. Def
code def top
{*
# Include <stdio.h>
# Include <stdlib.h>
# Include <pthread.h>
# Include <db_cxx.h>
# Include ".. / hblib / consts.hh"
# Include ".. / hblib / ll.hh"
# Include ".. / hblib / utils.hh"
# Include ".. / hblib / hdb.hh"
# Include "tbmain.hh"
# Include "dbmain.hh"
*}
option
{
file = "main";
namespace = "hb";
};
table supplier
{
char [12] name.!; / / key uh; / / unq, hash
char [40] desc;
};
table thing
{
supplier + tsupplier; / / зовнішня посилання
char [12] name.!; / / key uh; / / unq, hash
char [40] desc;
};
end
У результаті роботи транслятора отримуємо 3 файли: файл опису структур записів таблиць, файл визначення самих таблиць і бази і файл її реалізації:
hbmain.hh
namespace hb {
using namespace hb;
class mainEnv;
struct supplierKey
{
db_recno_t key;
inline void Export (FILE * f);
inline void Import (char *, uint);
supplierKey (const db_recno_t & key_temp);
supplierKey () {}
} __attribute__ ((Packed));
struct supplierVal
{
char name [12];
char desc [40];
inline void Export (FILE * f);
inline void Import (char *, uint);
supplierVal (char * name_temp, char * desc_temp);
supplierVal () {}
} __attribute__ ((Packed));
class qsupplier: public hbTable <supplierKey,supplierVal> {
mainEnv & menv;
public:
qsupplier (mainEnv &);
inline void RefInit ();
static void GetRef_supplier (uint, char *, char *, db_recno_t * &, uint &);
static int qsupplier:: idx_name (Db * db, const Dbt * pk, const Dbt * pv, Dbt * fv);
};
struct isupplier_name
{
char name [12];
char * Getname () {return name;}
isupplier_name (char * name_temp);
} __attribute__ ((Packed));
//------------------------------------------------ ------------------------------
struct thingKey
{
db_recno_t key;
inline void Export (FILE * f);
inline void Import (char *, uint);
thingKey (const db_recno_t & key_temp);
thingKey () {}
} __attribute__ ((Packed));
struct thingVal
{
db_recno_t tsupplier;
char name [12];
char desc [40];
inline void Export (FILE * f);
inline void Import (char *, uint);
thingVal (const db_recno_t & tsupplier_temp, char * name_temp, char * desc_temp);
thingVal () {}
} __attribute__ ((Packed));
class qthing: public hbTable <thingKey,thingVal> {
mainEnv & menv;
public:
qthing (mainEnv &);
inline void RefInit ();
static void GetRef_thing (uint, char *, char *, db_recno_t * &, uint &);
static int qthing:: idx_name (Db * db, const Dbt * pk, const Dbt * pv, Dbt * fv);
};
struct ithing_name
{
char name [12];
char * Getname () {return name;}
ithing_name (char * name_temp);
} __attribute__ ((Packed));
//------------------------------------------------ ------------------------------
};
dbmain.hh
namespace hb {
using namespace hb;
enum idxNames {
dbn_supplier_name = 0, dbn_thing_name = 0};
class mainEnv;
class mainEnv: public hbEnv {
public:
mainEnv (const char *, ushort flt = LL_DEBUG, Log * LogObj1 = 0);
qsupplier & tsupplier;
qthing & tthing;
};
};
dbmain.cc
# Include <stdio.h>
# Include <stdlib.h>
# Include <pthread.h>
# Include <db_cxx.h>
# Include ".. / hblib / consts.hh"
# Include ".. / hblib / ll.hh"
# Include ".. / hblib / utils.hh"
# Include ".. / hblib / hdb.hh"
# Include "tbmain.hh"
# Include "dbmain.hh"
/ / # Include <stdio.h>
/ / # Include <stdlib.h>
/ / # Include <time.h>
/ / # Include <string.h>
/ / # Include <stdarg.h>
/ / # Include <pthread.h>
/ / # Include <unistd.h>
/ / # Include <dirent.h>
/ / # Include <ctype.h>
/ / # Include <sys/types.h>
/ / # Include ".. / hibase / consts.hh"
/ / # Include ".. / hibase / ll.hh"
/ / # Include ".. / hibase / hdb.hh"
/ / # Include "myconst.hh"
/ / # Include "dbmain.hh"
namespace hb {};
using namespace hb;
namespace hb {};
using namespace hb;
# Define NUMDB 2
enum maindbNames {
dbnsupplier = 0, dbnthing};
static hbInit tblIndexes [] = {
{"Supplier:: name", "supplier.i", "name", DB_HASH, 0,0,0, & qsupplier:: idx_name, 0, 0},
{"Thing:: name", "thing.i", "name", DB_HASH, 0,0,0, & qthing:: idx_name, 0, 0}
};
static hbInit tblInits [] = {
{"Supplier", "supplier.q", 0, DB_QUEUE, 0,1, tblIndexes + 0, 0, & qsupplier:: GetRef_supplier, 0},
{"Thing", "thing.q", 0, DB_QUEUE, 0,1, tblIndexes + 1, 0, & qthing:: GetRef_thing, 1}
};
envInit mainEnvInit = {
NUMDB,
"$ Id: tblproc.pm, v 1.35 2004/01/10 23:57:48 bora Exp $"
};
qsupplier:: qsupplier (mainEnv & env): hbTable <supplierKey,supplierVal> (env, tblInits [dbnsupplier]), menv (env)
{}
void qsupplier:: RefInit ()
{
}
void qsupplier:: GetRef_supplier (uint num, char * key, char * val, db_recno_t * & refs, uint & ref_count)
{
supplierKey * key1 = (supplierKey *) key;
supplierVal * val1 = (supplierVal *) val;
}
void supplierKey:: Export (FILE * f)
{
fprintf (f, "% d", key);
}
void supplierKey:: Import (char * buf, uint len)
{
int j, num, i = 0;
char temp;
{J = i; for (; i <len; i + +) if (buf [i ]==',' | | buf [i ]=='}') break;}
temp = buf [i]; buf [i] = '\ 0', sscanf (buf + j, "% d", & key);
buf [i] = temp;
i + +;
}
supplierKey:: supplierKey (const db_recno_t & key_temp)
{
memset (this, 0, sizeof (* this));
key = key_temp;
}
void supplierVal:: Export (FILE * f)
{
fprintf (f ,"{");
CharArrInToStr (f, name, 12);
fprintf (f ,"}");
fprintf (f ,",");
fprintf (f ,"{");
CharArrInToStr (f, desc, 40);
fprintf (f ,"}");
}
void supplierVal:: Import (char * buf, uint len)
{
int j, num, i = 0;
char temp;
if (buf [i + +] !='{')
throw hbExcp (3, LL_CRITICAL, 0, "Помилка імпорту: + покажчик на таблицю = 0.");
j = i;
for (; i <len; i + +)
{
if (buf [i] == '}' & & buf [i-1]! = '\ \')
break;
}
StrToCharArr (buf + j, ij, name, 12);
i + = 2;
if (buf [i + +] !='{')
throw hbExcp (3, LL_CRITICAL, 0, "Помилка імпорту: + покажчик на таблицю = 0.");
j = i;
for (; i <len; i + +)
{
if (buf [i] == '}' & & buf [i-1]! = '\ \')
break;
}
StrToCharArr (buf + j, ij, desc, 40);
i + = 2;
}
supplierVal:: supplierVal (char * name_temp, char * desc_temp)
{
memset (this, 0, sizeof (* this));
strncpy (name, name_temp, sizeof (name));
strncpy (desc, desc_temp, sizeof (desc));
}
isupplier_name:: isupplier_name (char * name_temp)
{
memcpy (name, name_temp, sizeof (name));
}
int qsupplier:: idx_name (Db * db, const Dbt * pk, const Dbt * pv, Dbt * fv)
{
supplierVal * v = (supplierVal *) (pv-> get_data ());
fv-> set_data (v-> name);
fv-> set_size (sizeof (isupplier_name));
return 0;
}
//------------------------------------------------ ------------------------------
qthing:: qthing (mainEnv & env): hbTable <thingKey,thingVal> (env, tblInits [dbnthing]), menv (env)
{}
void qthing:: RefInit ()
{
ref.reftables [0]. type = '+';
ref.reftables [0]. reftable = & menv.tsupplier;
}
void qthing:: GetRef_thing (uint num, char * key, char * val, db_recno_t * & refs, uint & ref_count)
{
thingKey * key1 = (thingKey *) key;
thingVal * val1 = (thingVal *) val;
if (num == 0)
{
refs = & val1-> tsupplier; ref_count = 1;
}
}
void thingKey:: Export (FILE * f)
{
fprintf (f, "% d", key);
}
void thingKey:: Import (char * buf, uint len)
{
int j, num, i = 0;
char temp;
{J = i; for (; i <len; i + +) if (buf [i ]==',' | | buf [i ]=='}') break;}
temp = buf [i]; buf [i] = '\ 0', sscanf (buf + j, "% d", & key);
buf [i] = temp;
i + +;
}
thingKey:: thingKey (const db_recno_t & key_temp)
{
memset (this, 0, sizeof (* this));
key = key_temp;
}
void thingVal:: Export (FILE * f)
{
fprintf (f, "% d", tsupplier);
fprintf (f ,",");
fprintf (f ,"{");
CharArrInToStr (f, name, 12);
fprintf (f ,"}");
fprintf (f ,",");
fprintf (f ,"{");
CharArrInToStr (f, desc, 40);
fprintf (f ,"}");
}
void thingVal:: Import (char * buf, uint len)
{
int j, num, i = 0;
char temp;
{J = i; for (; i <len; i + +) if (buf [i ]==',' | | buf [i ]=='}') break;}
temp = buf [i]; buf [i] = '\ 0', sscanf (buf + j, "% d", & tsupplier);
buf [i] = temp;
if (tsupplier == 0) throw hbExcp (3, LL_CRITICAL, 0, "Помилка імпорту: + покажчик на таблицю = 0.");
i + +;
if (buf [i + +] !='{')
throw hbExcp (3, LL_CRITICAL, 0, "Помилка імпорту: не можу розпарсити рядок.");
j = i;
for (; i <len; i + +)
{
if (buf [i] == '}' & & buf [i-1]! = '\ \')
break;
}
StrToCharArr (buf + j, ij, name, 12);
i + = 2;
if (buf [i + +] !='{')
throw hbExcp (3, LL_CRITICAL, 0, "Помилка імпорту: не можу розпарсити рядок.");
j = i;
for (; i <len; i + +)
{
if (buf [i] == '}' & & buf [i-1]! = '\ \')
break;
}
StrToCharArr (buf + j, ij, desc, 40);
i + = 2;
}
thingVal:: thingVal (const db_recno_t & tsupplier_temp, char * name_temp, char * desc_temp)
{
memset (this, 0, sizeof (* this));
tsupplier = tsupplier_temp;
strncpy (name, name_temp, sizeof (name));
strncpy (desc, desc_temp, sizeof (desc));
}
ithing_name:: ithing_name (char * name_temp)
{
memcpy (name, name_temp, sizeof (name));
}
int qthing:: idx_name (Db * db, const Dbt * pk, const Dbt * pv, Dbt * fv)
{
thingVal * v = (thingVal *) (pv-> get_data ());
fv-> set_data (v-> name);
fv-> set_size (sizeof (ithing_name));
return 0;
}
//------------------------------------------------ ------------------------------
mainEnv:: mainEnv (const char * path, ushort flt, Log * LogObj1): hbEnv (path, mainEnvInit, flt, LogObj1),
tsupplier (* (new qsupplier (* this))),
tthing (* (new qthing (* this)))
{
dbs [dbnsupplier] = &tsupplier; tsupplier.RefInit ();
dbs [dbnthing] = &tthing; tthing.RefInit ();
}
Файл приклад описаний так
int main (void)
{
mainEnv env (". / DataBase /");
/ / Створюємо базу, тобто формуємо необхідні файли для всіх таблиць
env.Init (bexcp (16, "main", "example.cc", 3, LL_DEBUG));
env.Close (bexcp (16, "main", "example.cc", 3, LL_DEBUG));
env.ImportDB (bexcp (16, "main", "example.cc", 3, LL_DEBUG ),"./ Export1.ex ");
env.ExportDB (bexcp (16, "main", "example.cc", 3, LL_DEBUG ),"./ Export.ex ");
/ / Перевіряємо на індексну цілісність
env.CheckForIdx (bexcp (16, "main", "example.cc", 3, LL_DEBUG));
/ / Перевіряємо на посилальну цілісність
env.CheckForRef (bexcp (16, "main", "example.cc", 3, LL_DEBUG));
env.OpenTDSMode (); / / відкриваємо її в нормальному транзакційному режимі
try
{
hbTxn tx (env);
tx.Start ();
supplierKey key = {1};
supplierVal val = {"Boris", "Boss"};
env.tsupplier.Put (& tx, & key, & val);
thingKey key = {1};
thingVal val = {1, "Computer", "best"};
env.tthing.Put (& tx, & key, & val);
tx.commit ();
}
catch (hbExcp & excp)
{
cout <<excp.what ();
}
env.Close ();
return 0;
}
7.Заключение
На сьогоднішній день навігаційно-мережеві бази знову набули своєї актуальності. Це обумовлюється, головним чином, їх дуже високою швидкістю роботи, навіть, незважаючи на складність розуміння для некваліфікованого фахівця. Щоб полегшити роботу програмісту з такою базою засобами BerkeleyDB до неї був введений генератор об'єктно-орієнтованого інтерфейсу. Це дозволило якісно поліпшити швидкість розробки на С + + і підвищити рівень абстракції роботи з нею.

8.Спісок використовуваної літератури:
1) http://www.sleepycat.com - офіційний сайт компанії-розробника BerkeleyDB
2) The Object Data Standard ODMG 3.0. New York, MK, 2002.
3) Gamma E., Helm R., Johnson R., Vlissides J. Design Patterns: Elements of reusable object-oriented software, Reading, MA: Addison-Westley, 1995.
4) Герберт Шілдт. Повний довідник по С. М., Вільямс, 2002.