A Database class
상속: IDisposable
예제 #1
0
        /// <summary>
        /// Opens a Database in this Environment
        /// </summary>
        /// <remarks>
        /// This method wraps the native ups_env_open_db function.
        /// </remarks>
        /// <param name="name">The name of the Database. If a Database
        /// with this name does not exist, the function will throw
        /// <see cref="UpsConst.UPS_DATABASE_NOT_FOUND"/>.</param>
        /// <param name="flags">Optional flags for this operation, combined
        /// with bitwise OR. Possible flags are:
        ///   <list type="bullet">
        ///   <item><see cref="UpsConst.UPS_READ_ONLY" />
        ///     Opens the database for reading.</item>
        ///   </list>
        /// </param>
        /// <param name="parameters">An array of <see cref="Parameter" />
        /// structures. The following parameters are available:<br />
        ///   <list type="bullet">
        ///   </list>
        /// </param>
        /// <exception cref="DatabaseException">
        ///   <list type="bullet">
        ///   <item><see cref="UpsConst.UPS_INV_PARAMETER"/>
        ///     if an invalid combination of flags was specified</item>
        ///   <item><see cref="UpsConst.UPS_DATABASE_NOT_FOUND"/>
        ///     if a Database with this name does not exist</item>
        ///   <item><see cref="UpsConst.UPS_DATABASE_ALREADY_OPEN"/>
        ///     if this Database was already opened</item>
        ///   <item><see cref="UpsConst.UPS_OUT_OF_MEMORY"/>
        ///     if memory could not be allocated</item>
        ///   <item><see cref="UpsConst.UPS_WOULD_BLOCK"/>
        ///     if another process has locked the file</item>
        ///   </list>
        /// </exception>
        /// <returns>The new Database object</returns>
        public Database OpenDatabase(short name, int flags,
        Parameter[] parameters)
        {
            int st;
              IntPtr dbh = new IntPtr(0);
              if (parameters != null)
            parameters = AppendNullParameter(parameters);
              lock (this) {
            st = NativeMethods.EnvOpenDatabase(handle, out dbh,
            name, flags, parameters);
              }
              if (st != 0)
            throw new DatabaseException(st);

              Database db = new Database(dbh);
              databases.Add(db);
              return db;
        }
예제 #2
0
        private void Recovery()
        {
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            env.Create("ntest.db", UpsConst.UPS_ENABLE_RECOVERY);
            db = env.CreateDatabase(1);

            byte[] k = new byte[5];
            byte[] r = new byte[5];
            db.Insert(k, r);
            db.Close();
            env.Close();
        }
예제 #3
0
        private void ApproxMatching()
        {
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            byte[] k1 = new byte[5];
            byte[] r1 = new byte[5];
            k1[0] = 1; r1[0] = 1;
            byte[] k2 = new byte[5];
            byte[] r2 = new byte[5];
            k2[0] = 2; r2[0] = 2;
            byte[] k3 = new byte[5];
            byte[] r3 = new byte[5];
            k3[0] = 3; r3[0] = 3;
            try
            {
                env.Create("ntest.db");
                db = env.CreateDatabase(1);
                db.Insert(k1, r1);
                db.Insert(k2, r2);
                db.Insert(k3, r3);

                Cursor c = new Cursor(db);
                byte[] r = c.Find(k2, UpsConst.UPS_FIND_GT_MATCH);
                checkEqual(r, r3);
                checkEqual(k2, k3);
                k2[0] = 2;
                r = c.Find(k2, UpsConst.UPS_FIND_GT_MATCH);
                checkEqual(r, r1);
                checkEqual(k2, k1);
                db.Close();
                env.Close();
            }
            catch (DatabaseException e)
            {
                Assert.Fail("unexpected exception " + e);
            }
        }
예제 #4
0
 private void InsertKeyNegative()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     byte[] k = new byte[5];
     byte[] r = new byte[5];
     try {
         env.Create("ntest.db");
         db = env.CreateDatabase(1);
         db.Insert(k, r);
         db.Insert(k, r);
     }
     catch (DatabaseException e) {
         Assert.AreEqual(UpsConst.UPS_DUPLICATE_KEY, e.ErrorCode);
     }
     db.Close();
     env.Close();
 }
예제 #5
0
        private void InsertRecNo()
        {
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            byte[] r1 = new byte[5];
            byte[] r2;
            try
            {
                env.Create("ntest.db");
                db = env.CreateDatabase(1, UpsConst.UPS_RECORD_NUMBER);
                r1[0] = 1;
                var k = db.InsertRecNo(r1);
                r2 = db.Find(k);
                checkEqual(r1, r2);

                r1[0] = 2;
                k = db.InsertRecNo(r1);
                r2 = db.Find(k);
                checkEqual(r1, r2);

                r1[0] = 3;
                k = db.InsertRecNo(r1);
                r2 = db.Find(k);
                checkEqual(r1, r2);
            }
            catch (DatabaseException e)
            {
                Assert.Fail("unexpected exception " + e);
            }
            db.Close();
            env.Close();
        }
예제 #6
0
 private void FindUnknownKey()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     byte[] k = new byte[5];
     try {
         env.Create("ntest.db");
         db = env.CreateDatabase(1);
         byte[] r = db.Find(k);
     }
     catch (DatabaseException e) {
         Assert.AreEqual(UpsConst.UPS_KEY_NOT_FOUND, e.ErrorCode);
     }
     db.Close();
     env.Close();
 }
예제 #7
0
        private void InsertKey()
        {
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            byte[] k = new byte[5];
            byte[] r1 = new byte[5];
            byte[] r2;
            try {
                env.Create("ntest.db");
                db = env.CreateDatabase(1);
                k[0] = 1;
                r1[0] = 1;
                db.Insert(k, r1);
                r2 = db.Find(k);
                checkEqual(r1, r2);

                k[0] = 2;
                r1[0] = 2;
                db.Insert(k, r1);
                r2 = db.Find(k);
                checkEqual(r1, r2);

                k[0] = 3;
                r1[0] = 3;
                db.Insert(k, r1);
                r2 = db.Find(k);
                checkEqual(r1, r2);
                db.Close();
                env.Close();
            }
            catch (DatabaseException e) {
                Assert.Fail("unexpected exception " + e);
            }
        }
예제 #8
0
파일: Cursor.cs 프로젝트: jpexltd/upscaledb
 /// <summary>
 /// Constructor which creates a new Cursor in a Transaction
 /// </summary>
 public Cursor(Database db, Transaction txn)
 {
     Create(db, txn);
 }
예제 #9
0
파일: Cursor.cs 프로젝트: jpexltd/upscaledb
 /// <summary>
 /// Constructor which creates a new Cursor
 /// </summary>
 /// <param name="db">The Database of this Cursor</param>
 /// <param name="handle">The handle of this Cursor</param>
 internal Cursor(Database db, IntPtr handle)
 {
     this.db = db;
       this.handle = handle;
 }
예제 #10
0
파일: Cursor.cs 프로젝트: jpexltd/upscaledb
 /// <summary>
 /// Creates a new Cursor in a Transaction
 /// </summary>
 /// <remarks>
 /// This method wraps the native ups_cursor_create function.
 /// <br />
 /// Creates a new Database Cursor. Cursors can be used to traverse
 /// the Database from start to end or vice versa. Cursors can also
 /// be used to insert, delete or search Database items.
 ///
 /// A newly created Cursor does not point to any item in the Database.
 ///
 /// The application should close all Database Cursors before closing
 /// the Database.
 /// </remarks>
 /// <param name="db">The Database object</param>
 /// <param name="txn">The optional Transaction</param>
 /// <exception cref="DatabaseException">
 ///   <list type="bullet">
 ///   <item><see cref="UpsConst.UPS_OUT_OF_MEMORY"/>
 ///     if the new structure could not be allocated</item>
 ///   </list>
 /// </exception>
 public void Create(Database db, Transaction txn)
 {
     this.db = db;
       lock (this.db) {
     int st = NativeMethods.CursorCreate(out handle, db.Handle,
         txn != null ? txn.Handle : IntPtr.Zero, 0);
     if (st != 0)
       throw new DatabaseException(st);
     db.AddCursor(this);
       }
 }
예제 #11
0
파일: Cursor.cs 프로젝트: jpexltd/upscaledb
 /// <summary>
 /// Constructor which creates a new Cursor
 /// </summary>
 /// <param name="db">The Database of this Cursor</param>
 public Cursor(Database db)
 {
     Create(db);
 }
예제 #12
0
파일: Cursor.cs 프로젝트: jpexltd/upscaledb
 /// <summary>
 /// Creates a new Cursor
 /// </summary>
 ///
 /// <see cref="Cursor.Create(Database, Transaction)" />
 public void Create(Database db)
 {
     Create(db, null);
 }
예제 #13
0
파일: Cursor.cs 프로젝트: jpexltd/upscaledb
 /// <summary>
 /// Closes the Cursor
 /// </summary>
 /// <remarks>
 /// This method wraps the native ups_cursor_close function.
 /// <br />
 /// Closes this Cursor and frees allocated memory. All Cursors should
 /// be closed before closing the Database.
 /// </remarks>
 public void Close()
 {
     if (handle == IntPtr.Zero)
     return;
       int st;
       lock (db) {
     st = NativeMethods.CursorClose(handle);
       }
       if (st != 0)
     throw new DatabaseException(st);
       handle = IntPtr.Zero;
       db = null;
 }
예제 #14
0
        static void Main(string[] args)
        {
            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database[] db = new Database[3];
            Cursor[] cursor = new Cursor[3];

            /*
             * set up the customer and order data - these arrays will later
             * be inserted into the Databases
             */
            Customer[] customers = new Customer[4];
            customers[0] = new Customer(1, "Alan Antonov Corp.");
            customers[1] = new Customer(2, "Barry Broke Inc.");
            customers[2] = new Customer(3, "Carl Caesar Lat.");
            customers[3] = new Customer(4, "Doris Dove Brd.");

            Order[] orders = new Order[8];
            orders[0] = new Order(1, 1, "Joe");
            orders[1] = new Order(2, 1, "Tom");
            orders[2] = new Order(3, 3, "Joe");
            orders[3] = new Order(4, 4, "Tom");
            orders[4] = new Order(5, 3, "Ben");
            orders[5] = new Order(6, 3, "Ben");
            orders[6] = new Order(7, 4, "Chris");
            orders[7] = new Order(8, 1, "Ben");

            /*
             * Create a new Environment
             */
            env.Create("test.db");

            /*
             * then create the three Databases in this Environment; each Database
             * has a name - the first is our "customer" Database, the second
             * is for the "orders"; the third manages our 1:n relation and
             * therefore needs to enable duplicate keys
             */
            db[DBIDX_CUSTOMER] = env.CreateDatabase(DBNAME_CUSTOMER);
            db[DBIDX_ORDER]    = env.CreateDatabase(DBNAME_ORDER);
            db[DBIDX_C2O]      = env.CreateDatabase(DBNAME_C2O,
                    UpsConst.UPS_ENABLE_DUPLICATE_KEYS);

            /*
             * create a Cursor for each Database
             */
            cursor[DBIDX_CUSTOMER] = new Cursor(db[DBIDX_CUSTOMER]);
            cursor[DBIDX_ORDER] = new Cursor(db[DBIDX_ORDER]);
            cursor[DBIDX_C2O] = new Cursor(db[DBIDX_C2O]);

            /*
             * Insert the customers in the customer Database
             *
             * INSERT INTO customers VALUES (1, "Alan Antonov Corp.");
             * INSERT INTO customers VALUES (2, "Barry Broke Inc.");
             * etc.
             */
            for (int i = 0; i < customers.GetLength(0); i++) {
                byte[] key = customers[i].GetKey();
                byte[] rec = customers[i].GetRecord();

                db[DBIDX_CUSTOMER].Insert(key, rec);
            }

            /*
             * Insert the orders in the order Database
             *
             * INSERT INTO orders VALUES (1, "Joe");
             * INSERT INTO orders VALUES (2, "Tom");
             * etc.
             */
            for (int i = 0; i < orders.GetLength(0); i++) {
                byte[] key = orders[i].GetKey();
                byte[] rec = orders[i].GetRecord();

                db[DBIDX_ORDER].Insert(key, rec);
            }

            /*
             * and now the 1:n relationships; the flag UPS_DUPLICATE creates
             * a duplicate key, if the key already exists
             *
             * INSERT INTO c2o VALUES (1, 1);
             * INSERT INTO c2o VALUES (2, 1);
             * etc
             */
            for (int i = 0; i < orders.GetLength(0); i++) {
                byte[] key = orders[i].GetCustomerKey();
                byte[] rec = orders[i].GetKey();

                db[DBIDX_C2O].Insert(key, rec, UpsConst.UPS_DUPLICATE);
            }

            /*
             * now start the queries - we want to dump each customer and
             * his orders
             *
             * loop over the customer; for each customer, loop over the
             * 1:n table and pick those orders with the customer id.
             * then load the order and print it
             *
             * the outer loop is similar to
             * SELECT * FROM customers WHERE 1;
             */
            while (1 == 1) {
                Customer c;

                try {
                    cursor[DBIDX_CUSTOMER].MoveNext();
                }
                catch (DatabaseException e) {
                    // reached end of Database?
                    if (e.ErrorCode == UpsConst.UPS_KEY_NOT_FOUND)
                        break;
                    Console.Out.WriteLine("cursor.MoveNext failed: " + e);
                    return;
                }

                // load the customer
                c = new Customer(cursor[DBIDX_CUSTOMER].GetKey(),
                        cursor[DBIDX_CUSTOMER].GetRecord());

                // print information about this customer
                Console.Out.WriteLine("customer " + c.id + " ('" + c.name + "')");

                /*
                 * loop over the 1:n table
                 *
                 * SELECT * FROM customers, orders, c2o
                 *      WHERE c2o.customer_id=customers.id AND
                 *          c2o.order_id=orders.id;
                 */
                try {
                    cursor[DBIDX_C2O].Find(c.GetKey());
                }
                catch (DatabaseException e) {
                    // no order for this customer?
                    if (e.ErrorCode == UpsConst.UPS_KEY_NOT_FOUND)
                        continue;
                    Console.Out.WriteLine("cursor.Find failed: " + e);
                    return;
                }

                do {
                    /*
                     * load the order; orderId is a byteArray with the ID of the
                     * Order; the record of the item is a byteArray with the
                     * name of the assigned employee
                     *
                     * SELECT * FROM orders WHERE id = order_id;
                     */
                    byte[] orderId = cursor[DBIDX_C2O].GetRecord();
                    cursor[DBIDX_ORDER].Find(orderId);
                    String assignee = enc.GetString(cursor[DBIDX_ORDER].GetRecord());

                    Console.Out.WriteLine("  order: " + BitConverter.ToInt32(orderId, 0) +
                        " (assigned to " + assignee + ")");

                    /*
                     * move to the next order of this customer
                     *
                     * the flag UPS_ONLY_DUPLICATES restricts the cursor
                     * movement to the duplicates of the current key.
                     */
                    try {
                        cursor[DBIDX_C2O].MoveNext(UpsConst.UPS_ONLY_DUPLICATES);
                    }
                    catch (DatabaseException e) {
                        // no more orders for this customer?
                        if (e.ErrorCode == UpsConst.UPS_KEY_NOT_FOUND)
                            break;
                        Console.Out.WriteLine("cursor.MoveNext failed: " + e);
                        return;
                    }
                } while (1 == 1);
            }
        }
예제 #15
0
        private void EraseKeyTwice()
        {
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            byte[] k = new byte[5];
            byte[] r = new byte[5];

            env.Create("ntest.db");
            db = env.CreateDatabase(1);
            db.Insert(k, r);
            byte[] r2 = db.Find(k);
            checkEqual(r, r2);
            db.Erase(k);

            try {
                db.Erase(k);
            }
            catch (DatabaseException e) {
                Assert.AreEqual(UpsConst.UPS_KEY_NOT_FOUND, e.ErrorCode);
            }
            db.Close();
            env.Close();
        }
예제 #16
0
 private void AutoCleanupCursors4()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     env.Create("ntest.db");
     db = env.CreateDatabase(1);
     Cursor cursor1 = new Cursor(db);
     Cursor cursor2 = cursor1.Clone();
     Cursor cursor3 = cursor1.Clone();
     Cursor cursor4 = cursor1.Clone();
     Cursor cursor5 = cursor1.Clone();
     cursor3.Close();
     cursor5.Close();
     // let gc do the cleanup
     env.Close();
 }
예제 #17
0
 private void FindKeyNull()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     try {
         env.Create("ntest.db");
         db = env.CreateDatabase(1);
         byte[] r = db.Find(null);
     }
     catch (NullReferenceException) {
     }
     db.Close();
     env.Close();
 }
예제 #18
0
 private void CreateInvalidParameter()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     Parameter[] param = new Parameter[3];
     param[1] = new Parameter();
     param[2] = new Parameter();
     try {
         env.Create("ntest.db");
         db = env.CreateDatabase(1, 0, param);
         db.Close();
         env.Close();
     }
     catch (DatabaseException e) {
         Assert.AreEqual(UpsConst.UPS_INV_PARAMETER, e.ErrorCode);
     }
 }
예제 #19
0
        private void GetKeyCount()
        {
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            env.Create("ntest.db");
            db = env.CreateDatabase(1);

            byte[] k = new byte[5];
            byte[] r = new byte[5];
            Assert.AreEqual(0, db.GetCount());
            db.Insert(k, r);
            Assert.AreEqual(1, db.GetCount());
            k[0] = 1;
            db.Insert(k, r);
            Assert.AreEqual(2, db.GetCount());
            db.Close();
            env.Close();
        }
예제 #20
0
 private void CreateString()
 {
     Database db = new Database();
     Upscaledb.Environment env = new Upscaledb.Environment();
     try {
         env.Create("ntest.db");
         db = env.CreateDatabase(1);
         db.Close();
         env.Close();
         env.Open("ntest.db");
         db = env.OpenDatabase(1);
         db.Close();
         env.Close();
     }
     catch (DatabaseException e) {
         Assert.Fail("Unexpected exception " + e);
     }
 }
예제 #21
0
 private void InsertKeyInvalidParam()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     byte[] k = new byte[5];
     byte[] r = new byte[5];
     env.Create("ntest.db");
     db = env.CreateDatabase(1);
     try {
         db.Insert(null, r);
     }
     catch (NullReferenceException) {
     }
     try {
         db.Insert(k, null);
     }
     catch (NullReferenceException) {
     }
     try {
         db.Insert(k, r, 9999);
     }
     catch (DatabaseException e) {
         Assert.AreEqual(UpsConst.UPS_INV_PARAMETER, e.ErrorCode);
     }
     db.Close();
     env.Close();
 }
예제 #22
0
 private void CreateStringIntIntParameter()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     Parameter[] param = new Parameter[1];
     param[0] = new Parameter();
     param[0].name = UpsConst.UPS_PARAM_CACHESIZE;
     param[0].value = 1024;
     try {
         env.Create("ntest.db", 0, 0644, param);
         env.Close();
     }
     catch (DatabaseException e) {
         Assert.Fail("Unexpected exception " + e);
     }
 }
예제 #23
0
 private void InsertKeyOverwrite()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     byte[] k = new byte[5];
     byte[] r = new byte[5];
     try {
         env.Create("ntest.db");
         db = env.CreateDatabase(1);
         db.Insert(k, r);
         r[0] = 1;
         db.Insert(k, r, UpsConst.UPS_OVERWRITE);
         byte[] r2 = db.Find(k);
         checkEqual(r, r2);
         db.Close();
         env.Close();
     }
     catch (DatabaseException e) {
         Assert.Fail("unexpected exception " + e);
     }
 }
예제 #24
0
 private void CreateStringIntIntParameterNeg()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     Parameter[] param = new Parameter[1];
     param[0] = new Parameter();
     param[0].name = UpsConst.UPS_PARAM_CACHESIZE;
     param[0].value = 1024;
     try {
         env.Create("ntest.db", UpsConst.UPS_IN_MEMORY, 0644, param);
         env.Close();
     }
     catch (DatabaseException e) {
         Assert.AreEqual(UpsConst.UPS_INV_PARAMETER, e.ErrorCode);
     }
 }
예제 #25
0
        private Database OpenDatabase(string file)
        {
            List<Parameter> list = new List<Parameter>();

            Parameter param1 = new Parameter();
            param1.name = UpsConst.UPS_PARAM_CACHESIZE;
            param1.value = 768 * 1024 * 1024;
            list.Add(param1);

            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            env.Open(file, 0, list.ToArray());
            db = env.OpenDatabase(1);
            db.SetCompareFunc(new CompareFunc(NumericalCompareFunc));
            return db;
        }
예제 #26
0
 private void DatabaseClose()
 {
     Database db = new Database();
     try {
         db.Close();
     }
     catch (DatabaseException e) {
         Assert.Fail("Unexpected exception " + e);
     }
 }
예제 #27
0
        private void SetComparator()
        {
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            byte[] k = new byte[5];
            byte[] r = new byte[5];
            Parameter[] param = new Parameter[1];
            param[0] = new Parameter();
            param[0].name = UpsConst.UPS_PARAM_KEY_TYPE;
            param[0].value = UpsConst.UPS_TYPE_CUSTOM;

            compareCounter = 0;
            try {
                env.Create("ntest.db");
                db = env.CreateDatabase(1, 0, param);
                db.SetCompareFunc(new CompareFunc(MyCompareFunc));
                db.Insert(k, r);
                k[0] = 1;
                db.Insert(k, r);
                db.Close();
                env.Close();
            }
            catch (DatabaseException e) {
                Assert.Fail("unexpected exception " + e);
            }
            Assert.AreEqual(1, compareCounter);
        }
예제 #28
0
 private void EraseKeyNegative()
 {
     Upscaledb.Environment env = new Upscaledb.Environment();
     Database db = new Database();
     byte[] k = new byte[5];
     env.Create("ntest.db");
     db = env.CreateDatabase(1);
     try {
         db.Erase(null);
     }
     catch (NullReferenceException) {
     }
     db.Close();
     env.Close();
 }
예제 #29
0
 private void SetUp()
 {
     env = new Upscaledb.Environment();
     db = new Database();
     env.Create("ntest.db");
     db = env.CreateDatabase(1, UpsConst.UPS_ENABLE_DUPLICATE_KEYS);
 }
예제 #30
0
        private void Transactions()
        {
            Upscaledb.Environment env = new Upscaledb.Environment();
            Database db = new Database();
            env.Create("ntest.db", UpsConst.UPS_ENABLE_TRANSACTIONS);
            db = env.CreateDatabase(1);

            byte[] k = new byte[5];
            byte[] r = new byte[5];
            db.Insert(k, r);
            db.Close();
            env.Close();
        }