Tests and fixes for BLOB objects

src/deveeldb-nunit/Deveel.Data/SelectBlobTests.cs

@@ -0,0 +1,112 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+using Deveel.Data.Sql;
+using Deveel.Data.Sql.Expressions;
+using Deveel.Data.Sql.Objects;
+using Deveel.Data.Sql.Tables;
+using Deveel.Data.Sql.Types;
+using Deveel.Data.Store;
+
+using NUnit.Framework;
+
+namespace Deveel.Data.Deveel.Data {
+	[TestFixture]
+	public sealed class SelectBlobTests : ContextBasedTest {
+		private readonly byte[] testData;
+
+		public SelectBlobTests() {
+			var random = new Random();
+			testData = new byte[2048];
+			for (int i = 0; i < testData.Length; i++) {
+				testData[i] = (byte) random.Next();
+			}
+		}
+
+		protected override bool OnSetUp(string testName, IQuery query) {
+			CreateTable(query);
+			InsertData(query);
+			return true;
+		}
+
+		private void CreateTable(IQuery query) {
+			var tableInfo = new TableInfo(ObjectName.Parse("APP.test_table"));
+			var idColumn = tableInfo.AddColumn("id", PrimitiveTypes.Integer());
+			idColumn.DefaultExpression = SqlExpression.FunctionCall("UNIQUEKEY",
+				new SqlExpression[] { SqlExpression.Constant(tableInfo.TableName.FullName) });
+			tableInfo.AddColumn("first_name", PrimitiveTypes.String());
+			tableInfo.AddColumn("last_name", PrimitiveTypes.String());
+			tableInfo.AddColumn("birth_date", PrimitiveTypes.DateTime());
+			tableInfo.AddColumn("active", PrimitiveTypes.Boolean());
+			tableInfo.AddColumn("data", PrimitiveTypes.Blob(2048));
+
+			query.Session.Access().CreateTable(tableInfo);
+			query.Session.Access().AddPrimaryKey(tableInfo.TableName, "id", "PK_TEST_TABLE");
+		}
+
+		private void InsertData(IQuery query) {
+			var tableName = ObjectName.Parse("APP.test_table");
+			var table = query.Access().GetMutableTable(tableName);
+
+			var data = CreateData(query, testData);
+
+			var row = table.NewRow();
+			row["id"] = Field.Integer(1);
+			row["first_name"] = Field.String("Antonello");
+			row["last_name"] = Field.String("Provenzano");
+			row["birth_date"] = Field.Date(new SqlDateTime(1980, 06, 04));
+			row["active"] = Field.BooleanTrue;
+			row["data"] = new Field(PrimitiveTypes.Blob(2048), data);
+
+			table.AddRow(row);
+		}
+
+		private static SqlLongString CreateData(IQuery query, byte[] data) {
+			var lob = query.Session.CreateLargeObject(2048, true);
+			using (var stream = new ObjectStream(lob)) {
+				stream.Write(data, 0, data.Length);
+				stream.Flush();
+			}
+
+			lob.Complete();
+			return SqlLongString.Ascii(lob);
+		}
+
+		protected override bool OnTearDown(string testName, IQuery query) {
+			var tableName = ObjectName.Parse("APP.test_table");
+			query.Access().DropAllTableConstraints(tableName);
+			query.Access().DropObject(DbObjectType.Table, tableName);
+			return true;
+		}
+
+		[Test]
+		public void SelectData() {
+			var exp = (SqlQueryExpression)SqlExpression.Parse("SELECT * FROM test_table");
+			var result = Query.Select(exp);
+
+			Assert.IsNotNull(result);
+			Assert.IsTrue(result.Any());
+
+			var row = result.FirstOrDefault();
+
+			Assert.IsNotNull(row);
+
+			var data = row["data"];
+
+			Assert.IsFalse(Field.IsNullField(data));
+			Assert.IsInstanceOf<BinaryType>(data.Type);
+			Assert.AreEqual(SqlTypeCode.Blob, data.Type.TypeCode);
+			Assert.IsInstanceOf<SqlLongBinary>(data.Value);
+
+			var stream = ((SqlLongBinary)data.Value).GetInput();
+			var content = new byte[2048];
+			Assert.DoesNotThrow(() => stream.Read(content, 0, content.Length));
+
+			Assert.IsNotEmpty(content);
+			Assert.AreEqual(testData, content);
+		}
+
+	}
+}

src/deveeldb-nunit/Deveel.Data/SelectLobTests.cs → src/deveeldb-nunit/Deveel.Data/SelectClobTests.cs

@@ -14,7 +14,7 @@
 
 namespace Deveel.Data {
 	[TestFixture]
-	public class SelectLobTests : ContextBasedTest {
+	public class SelectClobTests : ContextBasedTest {
 		const string testBio = "A simple test string that can span several characters, " +
 					   "that is trying to be the longest possible, just to prove" +
 					   "the capacity of a LONG VARCHAR to handle very long strings. " +

src/deveeldb-nunit/deveeldb-nunit.csproj

@@ -185,8 +185,9 @@
     <Compile Include="Deveel.Data\DropViewTests.cs" />
     <Compile Include="Deveel.Data\FetchTests.cs" />
     <Compile Include="Deveel.Data\RollbackTests.cs" />
+    <Compile Include="Deveel.Data\SelectBlobTests.cs" />
     <Compile Include="Deveel.Data\SelectFromVariablesTests.cs" />
-    <Compile Include="Deveel.Data\SelectLobTests.cs" />
+    <Compile Include="Deveel.Data\SelectClobTests.cs" />
     <Compile Include="Deveel.Data\SelectPrivsTests.cs" />
     <Compile Include="Deveel.Data\SelectProductInfoTests.cs" />
     <Compile Include="Deveel.Data\SelectRoutineTests.cs" />

src/deveeldb/Deveel.Data.Sql.Objects/SqlLongBinary.cs

@@ -24,48 +24,79 @@
 
 namespace Deveel.Data.Sql.Objects {
 	public sealed class SqlLongBinary : ISqlBinary, IObjectRef, IDisposable {
-		private readonly ILargeObject largeObject;
+		private ILargeObject largeObject;
 
 		public static readonly SqlLongBinary Null = new SqlLongBinary(null);
 
 		public SqlLongBinary(ILargeObject largeObject) {
 			this.largeObject = largeObject;
 		}
 
+		~SqlLongBinary() {
+			Dispose(false);
+		}
+
+		private void AssertNotDisposed() {
+			if (largeObject == null)
+				throw new ObjectDisposedException("SqlLongBinary");
+		}
+
 		public int CompareTo(object obj) {
 			throw new NotImplementedException();
 		}
 
-		public int CompareTo(ISqlObject other) {
-			throw new NotImplementedException();
+		int IComparable<ISqlObject>.CompareTo(ISqlObject other) {
+			throw new NotSupportedException();
 		}
 
 		public bool IsNull {
 			get { return largeObject == null; }
 		}
 
-		public bool IsComparableTo(ISqlObject other) {
-			throw new NotImplementedException();
+		bool ISqlObject.IsComparableTo(ISqlObject other) {
+			return false;
 		}
 
 		public IEnumerator<byte> GetEnumerator() {
+			AssertNotDisposed();
 			throw new NotImplementedException();
 		}
 
 		IEnumerator IEnumerable.GetEnumerator() {
 			return GetEnumerator();
 		}
 
-		public long Length { get; private set; }
+		public long Length {
+			get {
+				AssertNotDisposed();
+				return largeObject.RawSize;
+			}
+		}
 
 		public Stream GetInput() {
-			throw new NotImplementedException();
+			AssertNotDisposed();
+			return new ObjectStream(largeObject);
 		}
 
 		public void Dispose() {
-			throw new NotImplementedException();
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		private void Dispose(bool disposing) {
+			if (disposing) {
+				if (largeObject != null)
+					largeObject.Dispose();
+			}
+
+			largeObject = null;
 		}
 
-		public ObjectId ObjectId { get; private set; }
+		public ObjectId ObjectId {
+			get {
+				AssertNotDisposed();
+				return largeObject.Id;
+			}
+		}
 	}
 }

src/deveeldb/Deveel.Data.Sql.Types/PrimitiveTypes.cs

@@ -229,6 +229,10 @@ public static class PrimitiveTypes {
 			return new BinaryType(sqlType, maxSize);
 		}
 
+		public static BinaryType Blob(int maxSize) {
+			return Binary(SqlTypeCode.Blob, maxSize);
+		}
+
 		public static IntervalType Interval(SqlTypeCode sqlType) {
 			return new IntervalType(sqlType);
 		}