public DatabaseEntry SecondaryKeyGen(
		    DatabaseEntry key, DatabaseEntry data)
        {
            DatabaseEntry dbtGen;
            dbtGen = new DatabaseEntry(data.Data);
            return dbtGen;
        }

        public void GetSecCursor(BTreeDatabase db,
		    string secFileName, SecondaryKeyGenDelegate keyGen,
		    out SecondaryBTreeDatabase secDB,
		    out SecondaryCursor cursor, bool ifCfg,
		    DatabaseEntry data)
        {
            // Open secondary database.
            SecondaryBTreeDatabaseConfig secCfg =
                new SecondaryBTreeDatabaseConfig(db, keyGen);
            secCfg.Creation = CreatePolicy.IF_NEEDED;
            secCfg.Duplicates = DuplicatesPolicy.SORTED;
            secDB = SecondaryBTreeDatabase.Open(secFileName, secCfg);

            int[] intArray = new int[4];
            intArray[0] = 0;
            intArray[1] = 1;
            intArray[2] = 2049;
            intArray[3] = 65537;
            for (int i = 0; i < 4; i++)
            {
                DatabaseEntry record = new DatabaseEntry(
                    BitConverter.GetBytes(intArray[i]));
                db.Put(record, record);
            }

            // Get secondary cursor on the secondary database.
            if (ifCfg == false)
                cursor = secDB.SecondaryCursor();
            else
                cursor = secDB.SecondaryCursor(new CursorConfig());

            // Position the cursor.
            if (data != null)
                Assert.IsTrue(cursor.Move(data, true));
        }

        public void CheckPartial(
		    DatabaseEntry key, uint kOffset, uint kLen,
		    DatabaseEntry pkey, uint pkOffset, uint pkLen,
		    DatabaseEntry data, uint dOffset, uint dLen)
        {
            if (key != null) {
                Assert.IsTrue(key.Partial);
                Assert.AreEqual(kOffset, key.PartialOffset);
                Assert.AreEqual(kLen, key.PartialLen);
                Assert.AreEqual(kLen, (uint)key.Data.Length);
            }

            if (pkey != null) {
                Assert.IsTrue(pkey.Partial);
                Assert.AreEqual(pkOffset, pkey.PartialOffset);
                Assert.AreEqual(pkLen, pkey.PartialLen);
                Assert.AreEqual(pkLen, (uint)pkey.Data.Length);
            }

            if (data != null) {
                Assert.IsTrue(data.Partial);
                Assert.AreEqual(dOffset, data.PartialOffset);
                Assert.AreEqual(dLen, data.PartialLen);
                Assert.AreEqual(dLen, (uint)data.Data.Length);
            }
        }

        /// <summary>
        /// Position the cursor at a specific key/data pair in the database, and
        /// store the key/data pair in <see cref="Cursor.Current"/>.
        /// </summary>
        /// <param name="recno">
        /// The specific numbered record of the database at which to position
        /// the cursor.
        /// </param>
        /// <param name="info">The locking behavior to use</param>
        /// <returns>
        /// True if the cursor was positioned successfully, false otherwise.
        /// </returns>
        public bool Move(uint recno, LockingInfo info) {
            DatabaseEntry key = new DatabaseEntry();
            key.Data = BitConverter.GetBytes(recno);
            DatabaseEntry data = new DatabaseEntry();

            return base.Get(key, data, DbConstants.DB_SET_RECNO, info);
        }

        public void Set(DatabaseEntry key, DatabaseEntry value, bool flush = false)
        {
            _btreeDb.Put(key, value);

            if (flush)
                _btreeDb.Sync();
        }

 /// <summary>
 /// Send a message on the message channel. The message is sent 
 /// asynchronously. The method does not wait for a response before
 /// returning. It usually completes quickly because it only waits for
 /// local TCP implementation to accept the bytes into its network data 
 /// buffer. However, this message could block briefly for longer
 /// messages, and/or if the network data buffer is nearly full. 
 /// It could even block indefinitely if the remote site is slow
 /// to read.
 /// </summary>
 /// <remarks>
 /// <para>
 /// To block while waiting for a response from a remote site, use 
 /// <see cref="SendRequest"/> instead of this method.
 /// </para>
 /// <para>
 /// The sent message is received and handled at remote sites using a
 /// message dispatch callback, which is configured using
 /// <see cref="DatabaseEnvironment.RepMessageDispatch"/>. This
 /// method may be used within the message dispatch callback on the
 /// remote site to send a reply or acknowledgement for messages that it
 /// receives and is handling.
 /// </para>
 /// <para>
 /// This method may be used on channels opened to any destination. See
 /// <see cref="DatabaseEnvironment.RepMgrChannel"/> for a list of 
 /// potential destinations.
 /// </para>
 /// </remarks>
 /// <param name="msg">
 /// An array of DatabaseEntry objects. Any flags for the DatabaseEntry
 /// objects are ignored.
 /// </param>
 public void SendMessage(DatabaseEntry[] msg) {
     int size = msg.Length;
     IntPtr[] dbts = new IntPtr[size];
     for (int i = 0; i < size; i++)
         dbts[i] = DBT.getCPtr(DatabaseEntry.getDBT(msg[i])).Handle;
     channel.send_msg(dbts, (uint)size, 0); 
 }

        public DatabaseEntry KeyGenOnLittleByte(
		    DatabaseEntry key, DatabaseEntry data)
        {
            byte[] byteArr = new byte[1];
            byteArr[0] = data.Data[0];
            DatabaseEntry dbtGen = new DatabaseEntry(byteArr);
            return dbtGen;
        }

        public DatabaseEntry KeyGenOnBigByte(
		    DatabaseEntry key, DatabaseEntry data)
        {
            byte[] byteArr = new byte[1];
            byteArr[0] = data.Data[data.Data.Length - 1];
            DatabaseEntry dbtGen = new DatabaseEntry(byteArr);
            return dbtGen;
        }

        public int SecondaryEntryComparison(
		    DatabaseEntry dbt1, DatabaseEntry dbt2)
        {
            int a, b;
            a = BitConverter.ToInt32(dbt1.Data, 0);
            b = BitConverter.ToInt32(dbt2.Data, 0);
            return a - b;
        }

 public void AddOneByCursor(HashCursor cursor)
 {
     DatabaseEntry key, data;
     KeyValuePair<DatabaseEntry, DatabaseEntry> pair;
     key = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("key"));
     data = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("data"));
     pair = new KeyValuePair<DatabaseEntry,DatabaseEntry>(key, data);
     cursor.Add(pair);
 }

 public DatabaseEntry MultipleKeyGen(DatabaseEntry key, DatabaseEntry data)
 {
     LinkedList<DatabaseEntry> skeys = new LinkedList<DatabaseEntry>();
     String dataStr = Configuration.strFromDBT(data);
     foreach (String s in dataStr.Split(',')) {
         DatabaseEntry tmp = new DatabaseEntry();
         Configuration.dbtFromString(tmp, s);
         skeys.AddLast(tmp);
     }
     return new MultipleDatabaseEntry(skeys, false);
 }

        public DatabaseEntry SecondaryKeyGen(
            DatabaseEntry key, DatabaseEntry data)
        {
            DatabaseEntry dbtGen;

            int skey = BitConverter.ToInt32(data.Data, 0);
            // don't index secondary key of 0
            if (skey == 0)
                return null;

            dbtGen = new DatabaseEntry(data.Data);
            return dbtGen;
        }

        public static void AddOneByCursor(Database db, Cursor cursor)
        {
            DatabaseEntry key, data;
            KeyValuePair<DatabaseEntry, DatabaseEntry> pair;

            // Add a record to db via cursor.
            key = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("key"));
            data = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("data"));
            pair = new KeyValuePair<DatabaseEntry,DatabaseEntry>(key, data);
            cursor.Add(pair);

            // Confirm that the record has been put to the database.
            Assert.IsTrue(db.Exists(key));
        }

        public void MoveToPos(string dbFileName, 
		    string dbSecFileName, bool ifPair)
        {
            // Open a primary database and its secondary database.
            BTreeDatabase db;
            SecondaryBTreeDatabase secDB;
            OpenSecDB(dbFileName, dbSecFileName, out db,
                out secDB);

            // Write ten records into the database.
            WriteRecords(db);

            SecondaryCursor secCursor = secDB.SecondaryCursor();
            DatabaseEntry key = new DatabaseEntry(
                BitConverter.GetBytes((int)0));
            DatabaseEntry notExistingKey = new DatabaseEntry(
                BitConverter.GetBytes((int)100));
            if (ifPair == false)
            {
                Assert.IsTrue(secCursor.Move(key, true));
                Assert.IsFalse(secCursor.Move(notExistingKey, true));
            }
            else
            {
                KeyValuePair<DatabaseEntry, KeyValuePair<
                    DatabaseEntry, DatabaseEntry>> pair =
                    new KeyValuePair<DatabaseEntry,
                    KeyValuePair<DatabaseEntry, DatabaseEntry>>(key,
                    new KeyValuePair<DatabaseEntry, DatabaseEntry>(
                    key, key));

                KeyValuePair<DatabaseEntry, KeyValuePair<
                    DatabaseEntry, DatabaseEntry>> notExistingPair;

                notExistingPair = new KeyValuePair<DatabaseEntry,
                    KeyValuePair<DatabaseEntry, DatabaseEntry>>(
                    notExistingKey, new KeyValuePair<
                    DatabaseEntry, DatabaseEntry>(
                    notExistingKey, notExistingKey));
                Assert.IsTrue(secCursor.Move(pair, true));
                Assert.IsFalse(secCursor.Move(notExistingPair, true));
            }

            secCursor.Close();
            secDB.Close();
            db.Close();
        }

        static void Main( string[] args )
        {
            try {
                var cfg = new HashDatabaseConfig();
                cfg.Duplicates = DuplicatesPolicy.UNSORTED;
                cfg.Creation = CreatePolicy.IF_NEEDED;
                cfg.CacheSize = new CacheInfo( 0, 64 * 1024, 1 );
                cfg.PageSize = 8 * 1024;

                Database db = HashDatabase.Open( "d:\\test.db", "hat_db", cfg );

                Console.WriteLine("db opened");

                var key = new DatabaseEntry();
                var data = new DatabaseEntry();

                key.Data = System.Text.Encoding.ASCII.GetBytes("key1");
                data.Data = System.Text.Encoding.ASCII.GetBytes("val1");

                try {
                    db.Put( key, data );
                    db.Put( key, data );
                }
                catch ( Exception ex ) {
                    Console.WriteLine( ex.Message );
                }

                using ( var dbc = db.Cursor() ) {

                    System.Text.ASCIIEncoding decode = new ASCIIEncoding();

                    /* Walk through the database and print out key/data pairs. */
                    Console.WriteLine( "All key : data pairs:" );
                    foreach ( KeyValuePair<DatabaseEntry, DatabaseEntry> p in dbc )
                        Console.WriteLine( "{0}::{1}",
                            decode.GetString( p.Key.Data ), decode.GetString( p.Value.Data ) );
                }

                db.Close();
                Console.WriteLine( "db closed" );
            }
            catch ( Exception ex ) {
                Console.WriteLine( ex.Message );
            }

            Console.ReadLine();
        }

        public void LoadInventoryDB(string dataDir)
        {
            DatabaseEntry key, data;
            string inventory_text_file = dataDir + "\\" + "inventory.txt";

            if (!File.Exists(inventory_text_file)) {
                Console.WriteLine("{0} does not exist.", inventory_text_file);
                return;
            }

            using (StreamReader sr = File.OpenText(inventory_text_file)) {
                Inventory inventory = new Inventory();
                string input;

                /* Text file fields are delimited by #, just read them in. */
                while ((input=sr.ReadLine())!=null) {
                    char [] delimiterPound = {'#'};
                    string [] fields = input.Split(delimiterPound);
            #if TEST_DEBUG
                    System.Console.WriteLine(input);
            #endif
                    inventory.Itemname = fields[0];
                    inventory.Sku = fields[1];
                    inventory.Price = float.Parse(fields[2]);
                    inventory.Quantity = int.Parse(fields[3]);
                    inventory.Category = fields[4];
                    inventory.Vendor = fields[5];

                    /* Insert key/data pairs into database. */
                    key = new DatabaseEntry();
                    key.Data = System.Text.Encoding.ASCII.GetBytes(
                        inventory.Sku);

                    byte [] bytes = inventory.getBytes();
                    data = new DatabaseEntry(bytes);

                    try {
                        myDbs.InventoryDB.Put(key, data);
                    } catch(Exception e) {
                        Console.WriteLine("LoadInventoryDB Error.");
                        Console.WriteLine(e.Message);
                        throw e;
                    }
                }
            }
        }

        public void showItem(string locateItem)
        {
            SecondaryCursor secCursor;

            /* searchKey is the key to find in the secondary db. */
            DatabaseEntry searchKey = new DatabaseEntry();
            searchKey.Data = System.Text.Encoding.ASCII.GetBytes(locateItem);

            /* Open a secondary cursor. */
            secCursor = this.myDbs.ItemSecbtreeDB.SecondaryCursor();

            /*
             * Search for the secondary. The primary key/data pair
             * associated with the given secondary key is stored in Current.
             * In the presence of duplicate key values, the first data
             * item in the set of duplicates is stored in Current.
             */
            if (secCursor.Move(searchKey, true)) {
                Inventory theInventory = new Inventory(
                    secCursor.Current.Value.Value.Data);

                /* Display the record. */
                displayInventory(theInventory);

                /* Get each duplicate. */
                while (secCursor.MoveNextDuplicate()) {
                    theInventory = new Inventory(
                        secCursor.Current.Value.Value.Data);
                    displayInventory(theInventory);
                }
            } else {
                Console.WriteLine("Could not find itemname {0} ", locateItem);
                Console.WriteLine();
                Console.WriteLine();
                return;
            }

            /* Close the cursor and the duplicate cursor. */
            secCursor.Close();
        }

        static public DatabaseEntry GetNextDBEntry(DatabaseEntry key)
        {

            long FirstPart;
            if (key.Data != null)
            {
                using (var ms = new MemoryStream(key.Data))
                {
                    using (var bw = new BinaryReader(ms))
                    {
                        FirstPart = bw.ReadInt64();
                        bw.Close();
                    }
                    ms.Close();
                }
            }
            else
            {
                FirstPart = 0;
            }
            int count = sizeof(long) + sizeof(byte) + sizeof(byte);
            var data = new byte[count];

            using (var ms = new MemoryStream(data))
            {
                using (var bw = new BinaryWriter(ms))
                {
                    bw.Write((FirstPart+1));
                    bw.Write((byte)0);
                    bw.Write((byte)0);
                    bw.Close();
                }
                ms.Close();
            }
            return new DatabaseEntry(data);

        }

 /// <summary>
 /// Store the key/data pair in the database, replacing any previously
 /// existing key if duplicates are disallowed, or adding a duplicate
 /// data item if duplicates are allowed.
 /// </summary>
 /// <overloads>
 /// <para>
 /// If the database supports duplicates, add the new data value at the
 /// end of the duplicate set. If the database supports sorted
 /// duplicates, the new data value is inserted at the correct sorted
 /// location.
 /// </para>
 /// </overloads>
 /// <param name="key">The key to store in the database</param>
 /// <param name="data">The data item to store in the database</param>
 /// <exception cref="DatabaseException">
 /// Partial put to a duplicate database, or <see cref="QueueDatabase"/>
 /// or <see cref="RecnoDatabase"/> with fixed-length records.
 /// </exception>
 public void Put(DatabaseEntry key, DatabaseEntry data)
 {
     Put(key, data, null);
 }

        /// <summary>
        /// Retrieve a key and all duplicate data items from the database.
        /// </summary>
        /// <param name="key">The key to search for</param>
        /// <param name="BufferSize">
        /// The initial size of the buffer to fill with duplicate data items. If
        /// the buffer is not large enough, it is automatically resized.
        /// </param>
        /// <param name="txn">
        /// <paramref name="txn"/> is a Transaction object returned from
        /// <see cref="DatabaseEnvironment.BeginTransaction"/>; if
        /// the operation is part of a Berkeley DB Concurrent Data Store group,
        /// <paramref name="txn"/> is a handle returned from
        /// <see cref="DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
        /// </param>
        /// <param name="info">The locking behavior to use.</param>
        /// <returns>
        /// A <see cref="KeyValuePair{T,T}"/>
        /// whose Key parameter is <paramref name="key"/> and whose Value
        /// parameter is the retrieved data items.
        /// </returns>
        public KeyValuePair<DatabaseEntry, MultipleDatabaseEntry> GetMultiple(
            DatabaseEntry key,
            int BufferSize, Transaction txn, LockingInfo info)
        {
            KeyValuePair<DatabaseEntry, DatabaseEntry> kvp;

            DatabaseEntry data = new DatabaseEntry();
            for (; ; ) {
                data.UserData = new byte[BufferSize];
                try {
                    kvp = Get(key, data, txn, info, DbConstants.DB_MULTIPLE);
                    break;
                } catch (MemoryException) {
                    int sz = (int)data.size;
                    if (sz > BufferSize)
                        BufferSize = sz;
                    else
                        BufferSize *= 2;
                }
            }
            MultipleDatabaseEntry dbe = new MultipleDatabaseEntry(kvp.Value);
            return new KeyValuePair<DatabaseEntry, MultipleDatabaseEntry>(
                kvp.Key, dbe);
        }