public void Open(string dbDir, string appName, Stream errStream)
        {
            this.dbDir = dbDir;
            Remove();

            // open vendor database
            Db db = new Db(DbCreateFlags.None);

            db.ErrorPrefix = appName;
            db.ErrorStream = errStream;
            vendorDb       = (DbBTree)db.Open(null, VendorDbName, null, DbType.BTree, Db.OpenFlags.Create, 0);

            // open inventory database
            db             = new Db(DbCreateFlags.None);
            db.ErrorPrefix = appName;
            db.ErrorStream = errStream;
            inventoryDb    = (DbBTree)db.Open(null, InventoryDbName, null, DbType.BTree, Db.OpenFlags.Create, 0);

            // open & associate vendor name index
            db              = new Db(DbCreateFlags.None);
            db.ErrorPrefix  = appName;
            db.ErrorStream  = errStream;
            db.BTreeCompare = VendorNameCompareFcn;
            db.SetFlags(DbFlags.Dup | DbFlags.DupSort);
            vendorNameIdx = (DbBTree)db.Open(null, VendorIndexName, null, DbType.BTree, Db.OpenFlags.Create, 0);
            inventoryDb.Associate(vendorNameIdx, GetVendorName, DbFile.AssociateFlags.Create);
            // unsafe {
            //   inventoryDb.Associate(vendorNameIdx, GetVendorNameFast, DbFile.AssociateFlags.Create);
            // }
        }
 public void Close()
 {
     if (vendorDb != null)
     {
         vendorDb.GetDb().Close();
         vendorDb = null;
     }
     if (inventoryDb != null)
     {
         inventoryDb.GetDb().Close();
         inventoryDb = null;
     }
     if (vendorNameIdx != null)
     {
         vendorNameIdx.GetDb().Close();
         vendorNameIdx = null;
     }
 }
Example #3
0
        private void AddRecord(DbBTree btree, Txn txn, Customer value, TextWriter writer)
        {
            // use standard .NET serialization, with the binary formatter
            keyStream.Position = 0;
            formatter.Serialize(keyStream, value.Name);
            DbEntry key = DbEntry.InOut(keyStream.GetBuffer(), 0, (int)keyStream.Position);

            dataStream.Position = 0;
            formatter.Serialize(dataStream, value);
            DbEntry data = DbEntry.InOut(dataStream.GetBuffer(), 0, (int)dataStream.Position);
            // calling PutNew means we don't want to overwrite an existing record
            WriteStatus status = btree.PutNew(txn, ref key, ref data);

            // if we tried to insert a duplicate, let's report it
            if (status == WriteStatus.KeyExist)
            {
                writer.WriteLine("Duplicate record: " + value.Name);
            }
        }
Example #4
0
        void initDatabase()
        {
            Db  db  = null;
            Txn txn = null;


            try {
                env = new Env(EnvCreateFlags.None);
                // configure for error and message reporting
                env.ErrorStream   = Console.OpenStandardError( );
                env.MessageStream = Console.OpenStandardOutput( );

                // initialize environment for locking, logging, memory pool and transactions
                Env.OpenFlags envFlags =
                    Env.OpenFlags.Create |
                    Env.OpenFlags.InitLock |
                    Env.OpenFlags.InitLog |
                    Env.OpenFlags.InitMPool |
                    Env.OpenFlags.InitTxn |
                    Env.OpenFlags.Recover;
                env.Open(dbHome, envFlags, 0);

                // create, configure and open database under a transaction
                txn = env.TxnBegin(null, Txn.BeginFlags.None);
                db  = env.CreateDatabase(DbCreateFlags.None);
                // set the BTree comparison function
                db.BTreeCompare = AppCompare;
                // error and message reporting already configured on environment
                // db.ErrorStream = errStream;
                // db.ErrorPrefix = Path.GetFileName(Application.ExecutablePath);
                // db.MessageStream = msgStream;
                dbInstance = (DbBTree)db.Open(
                    txn, dbName, null, DbType.BTree, Db.OpenFlags.Create, 0);
                txn.Commit(Txn.CommitMode.None);
            }
            catch {
            }

            isInited = true;
        }
Example #5
0
        private void loadBtn_Click(object sender, EventArgs e)
        {
            ClearDisplay();

            MemoryStream errStream = new MemoryStream();
            MemoryStream msgStream = new MemoryStream();
            TextWriter   errWriter = new StreamWriter(errStream);
            TextWriter   msgWriter = new StreamWriter(msgStream);

            Db  db  = null;
            Txn txn = null;
            Env env = null;

            try {
                env = new Env(EnvCreateFlags.None);
                // configure for error and message reporting
                env.ErrorStream   = errStream;
                env.ErrorPrefix   = Path.GetFileName(Application.ExecutablePath);
                env.MessageStream = msgStream;

                // initialize environment for locking, logging, memory pool and transactions
                Env.OpenFlags envFlags =
                    Env.OpenFlags.Create |
                    Env.OpenFlags.InitLock |
                    Env.OpenFlags.InitLog |
                    Env.OpenFlags.InitMPool |
                    Env.OpenFlags.InitTxn |
                    Env.OpenFlags.Recover;
                env.Open(homeDir, envFlags, 0);

                // create, configure and open database under a transaction
                txn = env.TxnBegin(null, Txn.BeginFlags.None);
                db  = env.CreateDatabase(DbCreateFlags.None);
                // set the BTree comparison function
                db.BTreeCompare = AppCompare;
                // error and message reporting already configured on environment
                // db.ErrorStream = errStream;
                // db.ErrorPrefix = Path.GetFileName(Application.ExecutablePath);
                // db.MessageStream = msgStream;
                DbBTree btree = (DbBTree)db.Open(
                    txn, myDb, null, DbType.BTree, Db.OpenFlags.Create, 0);
                txn.Commit(Txn.CommitMode.None);

                // create a sequence named '###sequence1' under a transaction
                txn = env.TxnBegin(null, Txn.BeginFlags.None);
                Sequence seq          = btree.CreateSequence();
                byte[]   seqName      = utf8.GetBytes("###sequence1");
                DbEntry  seqNameEntry = DbEntry.InOut(seqName);
                seq.Open(txn, ref seqNameEntry, Sequence.OpenFlags.Create);
                seq.Close();
                txn.Commit(Txn.CommitMode.None);

                // open sequence again, retrieve values and then remove the sequence
                seq = btree.CreateSequence();
                txn = env.TxnBegin(null, Txn.BeginFlags.None);
                // seq.CacheSize = 1000;  // cannot use transactions when CacheSize > 0
                seq.Open(txn, ref seqNameEntry, Sequence.OpenFlags.None);
                Int64 seqVal;
                for (int indx = 0; indx < 500; indx++)
                {
                    seqVal = seq.Get(txn, 1, Sequence.ReadFlags.None);
                }
                seq.Remove(txn, Sequence.RemoveFlags.None);
                txn.Commit(Txn.CommitMode.None);

                // add a few records under a transaction
                Customer cust;
                txn = env.TxnBegin(null, Txn.BeginFlags.None);

                cust = new Customer("John Doe", "122 Yonge Street", "Toronto", "ON", "M5R 5T9", DateTime.Parse("Dec 22, 1965"));
                AddRecord(btree, txn, cust, errWriter);

                cust = new Customer("Jane Doby", "23 Bloor Street", "Oshawa", "ON", "L1H 2K9", DateTime.Parse("Jun 1, 1962"));
                AddRecord(btree, txn, cust, errWriter);

                cust = new Customer("Rusty Nail", "77 Bond Street", "Markham", "ON", "L3T 7Y8", DateTime.Parse("Sep 9, 1915"));
                AddRecord(btree, txn, cust, errWriter);

                cust = new Customer("Rosy Cheek", "11 Adelaide Street", "Whitby", "ON", "K3P 4H4", DateTime.Parse("Jan 2, 1980"));
                AddRecord(btree, txn, cust, errWriter);

                // this last one is a duplicate of the first record
                cust = new Customer("John Doe", "1459 King Street", "Toronto", "ON", "N8N 2L0", DateTime.Parse("Apr 14, 1973"));
                AddRecord(btree, txn, cust, errWriter);

                txn.Commit(Txn.CommitMode.None);

                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine("K E Y   S T A T I S T I C S");
                msgWriter.WriteLine("==================================================");

                // get a key range, under a transaction
                txn = env.TxnBegin(null, Txn.BeginFlags.None);
                keyStream.Position = 0;
                formatter.Serialize(keyStream, "John Doe");
                DbEntry          key      = DbEntry.InOut(keyStream.GetBuffer(), 0, (int)keyStream.Position);
                DbBTree.KeyRange keyRange = btree.GetKeyRange(txn, ref key);
                txn.Commit(Txn.CommitMode.None);
                msgWriter.WriteLine();
                string msg = "KeyRange for 'John Doe': Less = {0}, Equal = {1}, Greater = {2}";
                msgWriter.WriteLine(string.Format(msg, keyRange.Less, keyRange.Equal, keyRange.Greater));
                msgWriter.WriteLine();

                // retrieve some database statistics
                TxnStats         stats   = env.GetTxnStats(StatFlags.None);
                DbBTree.Stats    btstats = btree.GetStats(null, DbFile.StatFlags.None);
                CacheFileStats[] cfStats = env.GetCacheFileStats(StatFlags.None);
                // we can also have them written to the message stream
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine("T R A N S A C T I O N   S T A T I S T I C S");
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine();
                msgWriter.Flush();
                env.PrintTxnStats(StatPrintFlags.None);
                msgWriter.WriteLine();
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine("L O G   S T A T I S T I C S");
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine();
                msgWriter.Flush();
                env.PrintLogStats(StatPrintFlags.All);
                msgWriter.WriteLine();
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine("L O C K   S T A T I S T I C S");
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine();
                msgWriter.Flush();
                env.PrintLogStats(StatPrintFlags.All);
                msgWriter.WriteLine();
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine("C A C H E   S T A T I S T I C S");
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine();
                msgWriter.Flush();
                env.PrintCacheStats(CacheStatPrintFlags.All);
                msgWriter.WriteLine();
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine("B T R E E   S T A T I S T I C S");
                msgWriter.WriteLine("==================================================");
                msgWriter.WriteLine();
                msgWriter.Flush();
                btree.PrintStats(DbFile.StatPrintFlags.All);
            }
            catch (BdbException) {
                if (txn != null && !txn.IsDisposed)
                {
                    txn.Abort();
                }
                // errors are reported through error stream already
                return;
            }
            catch (Exception ex) {
                if (txn != null && !txn.IsDisposed)
                {
                    txn.Abort();
                }
                errWriter.WriteLine(ex.ToString());
                return;
            }
            finally {
                if (db != null)
                {
                    db.Close();
                }
                if (env != null)
                {
                    env.Close();
                }
                msgWriter.Flush();
                string msgText = utf8.GetString(msgStream.GetBuffer());
                if (msgText != "")
                {
                    msgBox.Text = msgText;
                }
                msgWriter.Close();
                errWriter.Flush();
                string errText = utf8.GetString(errStream.GetBuffer());
                if (errText != "")
                {
                    errBox.Text = errText;
                    tabControl.SelectTab("errorPage");
                }
                errWriter.Close();
            }
        }