11496256613

Committed 24 Oct 2024 09:13AM UTC coverage: 55.977% (+0.03%) from 55.944%

Build # 11496256613

Build Type

Pull #3415

github

Committed by

web-flow

Commit Message

Merge 2462361b4 into 9ed6cac37

Pull Request Pull Request #3415: `[Fix]` Part-2 - LevelDbStore

Run Details

5798 of 8944 branches covered (64.83%)

Branch coverage included in aggregate %.

191 of 261 new or added lines in 12 files covered. (73.18%)

16 existing lines in 6 files now uncovered.

21819 of 40392 relevant lines covered (54.02%)

86222.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.87

/src/Plugins/LevelDBStore/IO/Data/LevelDB/DB.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// DB.cs file belongs to the neo project and is free
// software distributed under the MIT software license, see the
// accompanying file LICENSE in the main directory of the
// repository or http://www.opensource.org/licenses/mit-license.php
// for more details.
//
// Redistribution and use in source and binary forms with or without
// modifications are permitted.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace Neo.IO.Storage.LevelDB
{
    /// <summary>
    /// A DB is a persistent ordered map from keys to values.
    /// A DB is safe for concurrent access from multiple threads without any external synchronization.
    /// </summary>
    public class DB : LevelDBHandle, IEnumerable<KeyValuePair<byte[], byte[]>>
    {
        static void Throw(IntPtr error)
        {
            Throw(error, msg => new LevelDBException(msg));
        }

        static void Throw(IntPtr error, Func<string, Exception> exception)
        {
            if (error != IntPtr.Zero)
            {
                try
                {
                    var msg = Marshal.PtrToStringAnsi(error);
                    throw exception(msg);
                }
                finally
                {
                    Native.leveldb_free(error);
                }
            }
        }

        /// <summary>
        /// Open the database with the specified "name".
        /// </summary>
        public DB(string name, Options options)
        {
            Handle = Native.leveldb_open(options.Handle, name, out var error);
            Throw(error, msg => new UnauthorizedAccessException(msg));
        }

        public void Close()
        {
            (this as IDisposable).Dispose();
        }

        /// <summary>
        /// Set the database entry for "key" to "value".  
        /// </summary>
        public void Put(byte[] key, byte[] value)
        {
            Put(key, value, new WriteOptions());
        }

        /// <summary>
        /// Set the database entry for "key" to "value".  
        /// Note: consider setting new WriteOptions{ Sync = true }.
        /// </summary>
        public void Put(byte[] key, byte[] value, WriteOptions options)
        {
            Native.leveldb_put(Handle, options.Handle, key, checked((IntPtr)key.LongLength), value, checked((IntPtr)value.LongLength), out var error);
            Throw(error);
        }

        /// <summary>
        /// Remove the database entry (if any) for "key".  
        /// It is not an error if "key" did not exist in the database.
        /// </summary>
        public void Delete(byte[] key)
        {
            Delete(key, new WriteOptions());
        }

        /// <summary>
        /// Remove the database entry (if any) for "key".  
        /// It is not an error if "key" did not exist in the database.
        /// Note: consider setting new WriteOptions{ Sync = true }.
        /// </summary>
        public void Delete(byte[] key, WriteOptions options)
        {
            Native.leveldb_delete(Handle, options.Handle, key, checked((nint)key.LongLength), out var error);
            Throw(error);
        }

        public void Write(WriteBatch batch)
        {
            Write(batch, new WriteOptions());
        }

        public void Write(WriteBatch batch, WriteOptions options)
        {
            Native.leveldb_write(Handle, options.Handle, batch.Handle, out var error);
            Throw(error);
        }

        /// <summary>
        /// If the database contains an entry for "key" return the value,
        /// otherwise return null.
        /// </summary>
        public byte[] Get(byte[] key)
        {
            return Get(key, ReadOptions.Default);
        }

        /// <summary>
        /// If the database contains an entry for "key" return the value,
        /// otherwise return null.
        /// </summary>
        public byte[] Get(byte[] key, ReadOptions options)
        {
            var v = Native.leveldb_get(Handle, options.Handle, key, checked((IntPtr)key.LongLength), out var length, out var error);
            Throw(error);

            if (v != IntPtr.Zero)
            {
                try
                {

                    var len = (long)length;
                    int c = 0, si = 0;

                    var bytes = new byte[len];

                    while (si < len)
                    {
                        if (len - si > int.MaxValue)
                            c += int.MaxValue;
                        else
                            c += checked((int)(len - si));

                        // Method has a ~2GB limit.
                        Marshal.Copy(v, bytes, si, c);

                        si += c;
                    }
                    return bytes;
                }
                finally
                {
                    Native.leveldb_free(v);
                }
            }
            return null;
        }

        public bool Contains(byte[] key, ReadOptions options)
        {
            var value = Native.leveldb_get(Handle, options.Handle, key, key.Length, out _, out var error);
            Throw(error);

            if (value != IntPtr.Zero)
            {
                Native.leveldb_free(value);
                return true;
            }

            return false;
        }

        /// <summary>
        /// Return an iterator over the contents of the database.
        /// The result of CreateIterator is initially invalid (caller must
        /// call one of the Seek methods on the iterator before using it).
        /// </summary>
        public Iterator CreateIterator()
        {
            return CreateIterator(ReadOptions.Default);
        }

        /// <summary>
        /// Return an iterator over the contents of the database.
        /// The result of CreateIterator is initially invalid (caller must
        /// call one of the Seek methods on the iterator before using it).
        /// </summary>
        public Iterator CreateIterator(ReadOptions options)
        {
            return new Iterator(Native.leveldb_create_iterator(Handle, options.Handle));
        }

        /// <summary>
        /// Return a handle to the current DB state.  
        /// Iterators and Gets created with this handle will all observe a stable snapshot of the current DB state.  
        /// </summary>
        public SnapShot CreateSnapshot()
        {
            return new SnapShot(Native.leveldb_create_snapshot(Handle), this);
        }

        /// <summary>
        /// DB implementations can export properties about their state
        /// via this method.  If "property" is a valid property understood by this
        /// DB implementation, fills "*value" with its current value and returns
        /// true.  Otherwise returns false.
        ///
        /// Valid property names include:
        ///
        ///  "leveldb.num-files-at-level<N>" - return the number of files at level </N>,
        ///     where <N> is an ASCII representation of a level number (e.g. "0")</N>.
        ///  "leveldb.stats" - returns a multi-line string that describes statistics
        ///     about the internal operation of the DB.
        /// </summary>
        public string PropertyValue(string name)
        {
            string result = null;
            var ptr = Native.leveldb_property_value(Handle, name);
            if (ptr != IntPtr.Zero)
            {
                try
                {
                    return Marshal.PtrToStringAnsi(ptr);
                }
                finally
                {
                    Native.leveldb_free(ptr);
                }
            }
            return result;
        }

        /// <summary>
        /// If a DB cannot be opened, you may attempt to call this method to
        /// resurrect as much of the contents of the database as possible.
        /// Some data may be lost, so be careful when calling this function
        /// on a database that contains important information.
        /// </summary>
        public static void Repair(Options options, string name)
        {
            Native.leveldb_repair_db(options.Handle, name, out var error);
            Throw(error);
        }

        /// <summary>
        /// Destroy the contents of the specified database.
        /// Be very careful using this method.
        /// </summary>
        public static void Destroy(Options options, string name)
        {
            Native.leveldb_destroy_db(options.Handle, name, out var error);
            Throw(error);
        }

        protected override void FreeUnManagedObjects()
        {
            if (Handle != default)
                Native.leveldb_close(Handle);
        }

        public IEnumerator<KeyValuePair<byte[], byte[]>> GetEnumerator()
        {
            using var sn = CreateSnapshot();
            using var iterator = CreateIterator(new ReadOptions { Snapshot = sn });
            iterator.SeekToFirst();
            while (iterator.IsValid())
            {
                yield return new KeyValuePair<byte[], byte[]>(iterator.Key(), iterator.Value());
                iterator.Next();
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// DB.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12	using System;
13	using System.Collections;
14	using System.Collections.Generic;
15	using System.Runtime.InteropServices;
16
17	namespace Neo.IO.Storage.LevelDB
18	{
19	/// <summary>
20	/// A DB is a persistent ordered map from keys to values.
21	/// A DB is safe for concurrent access from multiple threads without any external synchronization.
22	/// </summary>
23	public class DB : LevelDBHandle, IEnumerable<KeyValuePair<byte[], byte[]>>
24	{
25	static void Throw(IntPtr error)
26	{	49✔
27	Throw(error, msg => new LevelDBException(msg));	49✔
28	}	49✔
29
30	static void Throw(IntPtr error, Func<string, Exception> exception)
31	{	60✔
32	if (error != IntPtr.Zero)	60!
NEW 33	{	×
34	try
NEW 35	{	×
NEW 36	var msg = Marshal.PtrToStringAnsi(error);	×
NEW 37	throw exception(msg);	×
38	}
39	finally
NEW 40	{	×
NEW 41	Native.leveldb_free(error);	×
NEW 42	}	×
43	}
44	}	60✔
45
46	/// <summary>
47	/// Open the database with the specified "name".
48	/// </summary>
49	public DB(string name, Options options)	11✔
50	{	11✔
51	Handle = Native.leveldb_open(options.Handle, name, out var error);	11✔
52	Throw(error, msg => new UnauthorizedAccessException(msg));	11✔
53	}	11✔
54
55	public void Close()
UNCOV 56	{	×
NEW 57	(this as IDisposable).Dispose();	×
UNCOV 58	}	×
59
60	/// <summary>
61	/// Set the database entry for "key" to "value".
62	/// </summary>
63	public void Put(byte[] key, byte[] value)
64	{	5✔
65	Put(key, value, new WriteOptions());	5✔
66	}	5✔
67
68	/// <summary>
69	/// Set the database entry for "key" to "value".
70	/// Note: consider setting new WriteOptions{ Sync = true }.
71	/// </summary>
72	public void Put(byte[] key, byte[] value, WriteOptions options)
73	{	15✔
74	Native.leveldb_put(Handle, options.Handle, key, checked((IntPtr)key.LongLength), value, checked((IntPtr)value.LongLength), out var error);	15✔
75	Throw(error);	15✔
76	}	15✔
77
78	/// <summary>
79	/// Remove the database entry (if any) for "key".
80	/// It is not an error if "key" did not exist in the database.
81	/// </summary>
82	public void Delete(byte[] key)
UNCOV 83	{	×
NEW 84	Delete(key, new WriteOptions());	×
UNCOV 85	}	×
86
87	/// <summary>
88	/// Remove the database entry (if any) for "key".
89	/// It is not an error if "key" did not exist in the database.
90	/// Note: consider setting new WriteOptions{ Sync = true }.
91	/// </summary>
92	public void Delete(byte[] key, WriteOptions options)
93	{	9✔
94	Native.leveldb_delete(Handle, options.Handle, key, checked((nint)key.LongLength), out var error);	9✔
95	Throw(error);	9✔
96	}	9✔
97
98	public void Write(WriteBatch batch)
99	{	2✔
100	Write(batch, new WriteOptions());	2✔
101	}	2✔
102
103	public void Write(WriteBatch batch, WriteOptions options)
104	{	2✔
105	Native.leveldb_write(Handle, options.Handle, batch.Handle, out var error);	2✔
106	Throw(error);	2✔
107	}	2✔
108
109	/// <summary>
110	/// If the database contains an entry for "key" return the value,
111	/// otherwise return null.
112	/// </summary>
113	public byte[] Get(byte[] key)
114	{	1✔
115	return Get(key, ReadOptions.Default);	1✔
116	}	1✔
117
118	/// <summary>
119	/// If the database contains an entry for "key" return the value,
120	/// otherwise return null.
121	/// </summary>
122	public byte[] Get(byte[] key, ReadOptions options)
123	{	16✔
124	var v = Native.leveldb_get(Handle, options.Handle, key, checked((IntPtr)key.LongLength), out var length, out var error);	16✔
125	Throw(error);	16✔
126
127	if (v != IntPtr.Zero)	16✔
128	{	7✔
129	try
130	{	7✔
131
132	var len = (long)length;	7✔
133	int c = 0, si = 0;	14✔
134
135	var bytes = new byte[len];	7✔
136
137	while (si < len)	14✔
138	{	7✔
139	if (len - si > int.MaxValue)	7!
NEW 140	c += int.MaxValue;	×
141	else
142	c += checked((int)(len - si));	7✔
143
144	// Method has a ~2GB limit.
145	Marshal.Copy(v, bytes, si, c);	7✔
146
147	si += c;	7✔
148	}	7✔
149	return bytes;	7✔
150	}
151	finally
152	{	7✔
153	Native.leveldb_free(v);	7✔
154	}	7✔
155	}
156	return null;	9✔
157	}	16✔
158
159	public bool Contains(byte[] key, ReadOptions options)
160	{	7✔
161	var value = Native.leveldb_get(Handle, options.Handle, key, key.Length, out _, out var error);	7✔
162	Throw(error);	7✔
163
164	if (value != IntPtr.Zero)	7✔
165	{	3✔
166	Native.leveldb_free(value);	3✔
167	return true;	3✔
168	}
169
170	return false;	4✔
171	}	7✔
172
173	/// <summary>
174	/// Return an iterator over the contents of the database.
175	/// The result of CreateIterator is initially invalid (caller must
176	/// call one of the Seek methods on the iterator before using it).
177	/// </summary>
178	public Iterator CreateIterator()
179	{	2✔
180	return CreateIterator(ReadOptions.Default);	2✔
181	}	2✔
182
183	/// <summary>
184	/// Return an iterator over the contents of the database.
185	/// The result of CreateIterator is initially invalid (caller must
186	/// call one of the Seek methods on the iterator before using it).
187	/// </summary>
188	public Iterator CreateIterator(ReadOptions options)
189	{	5✔
190	return new Iterator(Native.leveldb_create_iterator(Handle, options.Handle));	5✔
191	}	5✔
192
193	/// <summary>
194	/// Return a handle to the current DB state.
195	/// Iterators and Gets created with this handle will all observe a stable snapshot of the current DB state.
196	/// </summary>
197	public SnapShot CreateSnapshot()
198	{	3✔
199	return new SnapShot(Native.leveldb_create_snapshot(Handle), this);	3✔
200	}	3✔
201
202	/// <summary>
203	/// DB implementations can export properties about their state
204	/// via this method. If "property" is a valid property understood by this
205	/// DB implementation, fills "*value" with its current value and returns
206	/// true. Otherwise returns false.
207	///
208	/// Valid property names include:
209	///
210	/// "leveldb.num-files-at-level<N>" - return the number of files at level </N>,
211	/// where <N> is an ASCII representation of a level number (e.g. "0")</N>.
212	/// "leveldb.stats" - returns a multi-line string that describes statistics
213	/// about the internal operation of the DB.
214	/// </summary>
215	public string PropertyValue(string name)
216	{	×
NEW 217	string result = null;	×
NEW 218	var ptr = Native.leveldb_property_value(Handle, name);	×
NEW 219	if (ptr != IntPtr.Zero)	×
NEW 220	{	×
221	try
NEW 222	{	×
NEW 223	return Marshal.PtrToStringAnsi(ptr);	×
224	}
225	finally
NEW 226	{	×
NEW 227	Native.leveldb_free(ptr);	×
NEW 228	}	×
229	}
NEW 230	return result;	×
UNCOV 231	}	×
232
233	/// <summary>
234	/// If a DB cannot be opened, you may attempt to call this method to
235	/// resurrect as much of the contents of the database as possible.
236	/// Some data may be lost, so be careful when calling this function
237	/// on a database that contains important information.
238	/// </summary>
239	public static void Repair(Options options, string name)
NEW 240	{	×
NEW 241	Native.leveldb_repair_db(options.Handle, name, out var error);	×
NEW 242	Throw(error);	×
NEW 243	}	×
244
245	/// <summary>
246	/// Destroy the contents of the specified database.
247	/// Be very careful using this method.
248	/// </summary>
249	public static void Destroy(Options options, string name)
UNCOV 250	{	×
NEW 251	Native.leveldb_destroy_db(options.Handle, name, out var error);	×
NEW 252	Throw(error);	×
UNCOV 253	}	×
254
255	protected override void FreeUnManagedObjects()
256	{	11✔
257	if (Handle != default)	11✔
258	Native.leveldb_close(Handle);	11✔
259	}	11✔
260
261	public IEnumerator<KeyValuePair<byte[], byte[]>> GetEnumerator()
262	{	×
NEW 263	using var sn = CreateSnapshot();	×
NEW 264	using var iterator = CreateIterator(new ReadOptions { Snapshot = sn });	×
NEW 265	iterator.SeekToFirst();	×
NEW 266	while (iterator.IsValid())	×
NEW 267	{	×
NEW 268	yield return new KeyValuePair<byte[], byte[]>(iterator.Key(), iterator.Value());	×
NEW 269	iterator.Next();	×
NEW 270	}	×
UNCOV 271	}	×
272
273	IEnumerator IEnumerable.GetEnumerator()
UNCOV 274	{	×
NEW 275	return GetEnumerator();	×
UNCOV 276	}	×
277	}
278	}

neo-project / neo / 11496256613

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous