示例#1
0
 internal DatabaseStream(DB_STREAM dbstream,
                         DatabaseStreamConfig config)
 {
     this.dbs    = dbstream;
     isOpen      = true;
     this.config = config;
 }
示例#2
0
 internal DatabaseStream(DB_STREAM dbstream,
     DatabaseStreamConfig config)
 {
     this.dbs = dbstream;
     isOpen = true;
     this.config = config;
 }
示例#3
0
 /// <summary>
 /// Create a database stream pointing to a key/value pair where the
 /// data item is a blob with the given configuration.
 /// </summary>
 /// <param name="cfg">
 /// The configuration properties for the database stream.
 /// </param>
 /// <returns>A newly created database stream</returns>
 /// <exception cref="DatabaseException">
 /// Thrown if the data of the key/value pair it is pointing to is not
 /// a blob.
 /// </exception>
 public DatabaseStream DbStream(DatabaseStreamConfig cfg)
 {
     return new DatabaseStream(dbc.db_stream(cfg.flags), cfg);
 }
示例#4
0
 /// <summary>
 /// Create a database stream pointing to a key/value pair where the
 /// data item is a blob with the given configuration.
 /// </summary>
 /// <param name="cfg">
 /// The configuration properties for the database stream.
 /// </param>
 /// <returns>A newly created database stream</returns>
 /// <exception cref="DatabaseException">
 /// Thrown if the data of the key/value pair it is pointing to is not
 /// a blob.
 /// </exception>
 public DatabaseStream DbStream(DatabaseStreamConfig cfg)
 {
     return(new DatabaseStream(dbc.db_stream(cfg.flags), cfg));
 }
        /*
         * Test the blob database with or without environment.
         * 1. Config and open the environment;
          	 * 2. Verify the environment blob configs;
         	 * 3. Config and open the database;
         * 4. Verify the database blob configs;
         * 5. Insert and verify some blob data by database methods;
         * 6. Insert some blob data by cursor, update it and verify
         * the update by database stream and cursor;
         * 7. Verify the stats;
         * 8. Close all handles.
         * If "blobdbt" is true, set the data DatabaseEntry.Blob as
         * true, otherwise make the data DatabaseEntry reach the blob
         * threshold in size.
         */
        void TestBlobHashDatabase(uint env_threshold, string env_blobdir,
	    uint db_threshold, string db_blobdir, bool blobdbt)
        {
            if (env_threshold == 0 && db_threshold == 0)
            return;

            string hashDBName =
            testHome + "/" + testName + ".db";

            Configuration.ClearDir(testHome);
            HashDatabaseConfig cfg = new HashDatabaseConfig();
            cfg.Creation = CreatePolicy.ALWAYS;
            string blrootdir = "__db_bl";

            // Open the environment and verify the blob config.
            if (env_threshold > 0)
            {
            DatabaseEnvironmentConfig envConfig =
                new DatabaseEnvironmentConfig();
            envConfig.AutoCommit = true;
            envConfig.Create = true;
            envConfig.UseMPool = true;
            envConfig.UseLogging = true;
            envConfig.UseTxns = true;
            envConfig.UseLocking = true;
            envConfig.BlobThreshold = env_threshold;
            if (env_blobdir != null)
            {
                envConfig.BlobDir = env_blobdir;
                blrootdir = env_blobdir;
            }
            DatabaseEnvironment env = DatabaseEnvironment.Open(
                testHome, envConfig);
            if (env_blobdir == null)
                Assert.IsNull(env.BlobDir);
            else
                Assert.AreEqual(0,
                    env.BlobDir.CompareTo(env_blobdir));
            Assert.AreEqual(env_threshold, env.BlobThreshold);
            cfg.Env = env;
            hashDBName = testName + ".db";
            }

            // Open the database and verify the blob config.
            if (db_threshold > 0)
            cfg.BlobThreshold = db_threshold;
            if (db_blobdir != null)
            {
            cfg.BlobDir = db_blobdir;
            /*
             * The blob directory setting in the database
             * is effective only when it is opened without
             * an environment.
             */
            if (cfg.Env == null)
                blrootdir = db_blobdir;
            }

            HashDatabase db = HashDatabase.Open(hashDBName, cfg);
            Assert.AreEqual(
            db_threshold > 0 ? db_threshold : env_threshold,
            db.BlobThreshold);
            if (db_blobdir == null && cfg.Env == null)
            Assert.IsNull(db.BlobDir);
            else
            Assert.AreEqual(0,
                db.BlobDir.CompareTo(blrootdir));

            // Insert and verify some blob data by database methods.
            string[] records = {"a", "b", "c", "d", "e", "f", "g", "h",
            "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
            "t", "u", "v", "w", "x", "y", "z"};
            DatabaseEntry kdbt = new DatabaseEntry();
            DatabaseEntry ddbt = new DatabaseEntry();
            byte[] kdata, ddata;
            string str;
            KeyValuePair<DatabaseEntry, DatabaseEntry> pair;
            ddbt.Blob = blobdbt;
            Assert.AreEqual(blobdbt, ddbt.Blob);
            for (int i = 0; i < records.Length; i++)
            {
            kdata = BitConverter.GetBytes(i);
            str = records[i];
            if (!blobdbt)
            {
                for (int j = 0; j < db_threshold; j++)
                    str = str + records[i];
            }
            ddata = Encoding.ASCII.GetBytes(str);
            kdbt.Data = kdata;
            ddbt.Data = ddata;
            db.Put(kdbt, ddbt);
            try
            {
                pair = db.Get(kdbt);
            }
            catch (DatabaseException)
            {
                db.Close();
                if (cfg.Env != null)
                    cfg.Env.Close();
                throw new TestException();
            }
            Assert.AreEqual(ddata, pair.Value.Data);
            }

            /*
             * Insert some blob data by cursor, update it and verify
             * the update by database stream.
             */
            kdata = BitConverter.GetBytes(records.Length);
            ddata = Encoding.ASCII.GetBytes("abc");
            kdbt.Data = kdata;
            ddbt.Data = ddata;
            ddbt.Blob = true;
            Assert.IsTrue(ddbt.Blob);
            pair =
            new KeyValuePair<DatabaseEntry, DatabaseEntry>(kdbt, ddbt);
            CursorConfig dbcConfig = new CursorConfig();
            Transaction txn = null;
            if (cfg.Env != null)
            txn = cfg.Env.BeginTransaction();
            HashCursor cursor = db.Cursor(dbcConfig, txn);
            cursor.Add(pair);
            DatabaseStreamConfig dbsc = new DatabaseStreamConfig();
            dbsc.SyncPerWrite = true;
            DatabaseStream dbs = cursor.DbStream(dbsc);
            Assert.AreNotEqual(null, dbs);
            Assert.IsFalse(dbs.GetConfig.ReadOnly);
            Assert.IsTrue(dbs.GetConfig.SyncPerWrite);
            Assert.AreEqual(3, dbs.Size());
            DatabaseEntry sdbt = dbs.Read(0, 3);
            Assert.IsNotNull(sdbt);
            Assert.AreEqual(ddata, sdbt.Data);
            sdbt = new DatabaseEntry(Encoding.ASCII.GetBytes("defg"));
            Assert.IsTrue(dbs.Write(sdbt, 3));
            Assert.AreEqual(7, dbs.Size());
            sdbt = dbs.Read(0, 7);
            Assert.IsNotNull(sdbt);
            Assert.AreEqual(Encoding.ASCII.GetBytes("abcdefg"), sdbt.Data);
            dbs.Close();

            /*
             * Verify the database stream can not write when it is
             * configured to be read-only.
             */
            dbsc.ReadOnly = true;
            dbs = cursor.DbStream(dbsc);
            Assert.IsTrue(dbs.GetConfig.ReadOnly);
            try
            {
            Assert.IsFalse(dbs.Write(sdbt, 7));
            throw new TestException();
            }
            catch (DatabaseException)
            {
            }
            dbs.Close();

            // Verify the update by cursor.
            Assert.IsTrue(cursor.Move(kdbt, true));
            pair = cursor.Current;
            Assert.AreEqual(Encoding.ASCII.GetBytes("abcdefg"),
            pair.Value.Data);
            cursor.Close();
            if (cfg.Env != null)
            txn.Commit();

            /*
             * Verify the blob files are created in the expected location.
             * This part of test is disabled since BTreeDatabase.BlobSubDir
             * is not exposed to users.
             */
            //if (cfg.Env != null)
            //	blrootdir = testHome + "/" + blrootdir;
            //string blobdir = blrootdir + "/" + db.BlobSubDir;
            //Assert.AreEqual(records.Length + 1,
            //    Directory.GetFiles(blobdir, "__db.bl*").Length);
            //Assert.AreEqual(1,
            //    Directory.GetFiles(blobdir, "__db_blob_meta.db").Length);

            // Verify the stats.
            HashStats st = db.Stats();
            Assert.AreEqual(records.Length + 1, st.nBlobRecords);

            // Close all handles.
            db.Close();
            if (cfg.Env != null)
            cfg.Env.Close();

            /*
             * Remove the default blob directory
             * when it is not under the test home.
             */
            if (db_blobdir == null && cfg.Env == null)
            Directory.Delete("__db_bl", true);
        }