ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-14 01:25:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

fix decimal datatype handling (#1352)

Browse Source 
* Revert "Revert query execution changes (#1341)"

This reverts commit cb290cdbb5.

* fix decimal and money

* timestamp

* fix code and tests

* add sql variant test
This commit is contained in:
Alan Ren
2022-01-04 13:56:12 -08:00
committed by GitHub
parent 18ca177767
commit 995e9baeab
8 changed files with 304 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/QueryExecution/DataStorage/StorageDataReaderTests.cs
View File

@@ -44,6 +44,20 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution.DataSt
Assert.NotNull(bytes);
}
/// <summary>
/// Validate GetBytesWithMaxCapacity
/// </summary>
[Test]
public void GetLongDecimalTest()
{
// SQL Server support up to 38 digits of decimal
var storageReader = GetTestStorageDataReader(
"SELECT 99999999999999999999999999999999999999");
storageReader.DbDataReader.Read();
var value = storageReader.GetValue(0);
Assert.AreEqual("99999999999999999999999999999999999999", value.ToString());
}
/// <summary>
/// Validate GetCharsWithMaxCapacity
/// </summary>
@@ -63,7 +77,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution.DataSt
Assert.True(shortName.Length == 2);
Assert.Throws<ArgumentOutOfRangeException>(() => storageReader.GetBytesWithMaxCapacity(0, 0));
Assert.Throws<ArgumentOutOfRangeException>(() => storageReader.GetCharsWithMaxCapacity(0, 0));
Assert.Throws<ArgumentOutOfRangeException>(() => storageReader.GetCharsWithMaxCapacity(0, 0));
}
/// <summary>
@@ -94,10 +108,10 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution.DataSt
writer.Write(output);
Assert.True(writer.ToString().Equals(output));
writer.Write('.');
Assert.True(writer.ToString().Equals(output + '.'));
Assert.True(writer.ToString().Equals(output + '.'));
writer.Write(output);
writer.Write('.');
Assert.True(writer.ToString().Equals(output + '.'));
}
}
}
}

209
test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/QueryExecution/DataTypeTests.cs Normal file
View File

@@ -0,0 +1,209 @@
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using System;
using System.Threading.Tasks;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility;
using Microsoft.SqlTools.ServiceLayer.QueryExecution;
using Microsoft.SqlTools.ServiceLayer.SqlContext;
using Microsoft.SqlTools.ServiceLayer.Test.Common;
using NUnit.Framework;
namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.QueryExecution
{
public class DataTypeTests
{
[Test]
public async Task BigIntTest()
{
await ExecuteAndVerifyResult("SELECT CAST(100 AS BIGINT)", "100");
}
[Test]
public async Task SqlVariantTest()
{
await ExecuteAndVerifyResult("DECLARE @ID sql_variant = 90;select @ID", "90");
}
[Test]
public async Task BinaryTest()
{
await ExecuteAndVerifyResult("SELECT CAST(100 AS BINARY)", "0x000000000000000000000000000000000000000000000000000000000064");
}
[Test]
public async Task BitTest()
{
await ExecuteAndVerifyResult("SELECT CAST(0 AS BIT)", "0");
await ExecuteAndVerifyResult("SELECT CAST(1 AS BIT)", "1");
}
[Test]
public async Task CharTest()
{
await ExecuteAndVerifyResult("SELECT CAST('A' AS CHAR(1))", "A");
}
[Test]
public async Task DateTest()
{
await ExecuteAndVerifyResult("SELECT CAST('2020-01-01' AS DATE)", "2020-01-01");
}
[Test]
public async Task DateTimeTest()
{
await ExecuteAndVerifyResult("SELECT CAST('2020-01-01' AS DATETIME)", "2020-01-01 00:00:00.000");
}
[Test]
public async Task DateTime2Test()
{
await ExecuteAndVerifyResult("SELECT CAST('2020-01-01' AS DATETIME2)", "2020-01-01 00:00:00.0000000");
}
[Test]
public async Task DateTimeOffsetTest()
{
await ExecuteAndVerifyResult("SELECT CAST('2020-01-01' AS DATETIMEOFFSET)", "2020-01-01 00:00:00.0000000 +00:00");
}
[Test]
public async Task DecimalTest()
{
await ExecuteAndVerifyResult("SELECT CAST(99999999999999999999999999999999999999 AS DECIMAL(38))", "99999999999999999999999999999999999999");
}
[Test]
public async Task FloatTest()
{
await ExecuteAndVerifyResult("SELECT CAST(100.11 AS FLOAT)", "100.11");
}
[Test]
public async Task ImageTest()
{
await ExecuteAndVerifyResult("SELECT CAST('0' AS IMAGE)", "0x30");
}
[Test]
public async Task IntTest()
{
await ExecuteAndVerifyResult("SELECT CAST('100' AS INT)", "100");
}
[Test]
public async Task MoneyTest()
{
await ExecuteAndVerifyResult("SELECT CAST('100' AS MONEY)", "100.00");
}
[Test]
public async Task NCharTest()
{
await ExecuteAndVerifyResult("SELECT CAST(N'测' AS NCHAR(1))", "测");
}
[Test]
public async Task NTextTest()
{
await ExecuteAndVerifyResult("SELECT CAST(N'测试' AS NTEXT)", "测试");
}
[Test]
public async Task NVarCharTest()
{
await ExecuteAndVerifyResult("SELECT CAST(N'测试' AS NVARCHAR)", "测试");
}
[Test]
public async Task RealTest()
{
await ExecuteAndVerifyResult("SELECT CAST(100 AS REAL)", "100");
}
[Test]
public async Task SmallDateTimeTest()
{
await ExecuteAndVerifyResult("SELECT CAST('2021-01-01' AS SMALLDATETIME)", "2021-01-01 00:00:00");
}
[Test]
public async Task SmallIntTest()
{
await ExecuteAndVerifyResult("SELECT CAST(100 AS SMALLINT)", "100");
}
[Test]
public async Task SmallMoneyTest()
{
await ExecuteAndVerifyResult("SELECT CAST(100 AS SMALLMONEY)", "100.00");
}
[Test]
public async Task TextTest()
{
await ExecuteAndVerifyResult("SELECT CAST('abc' AS TEXT)", "abc");
}
[Test]
public async Task TimeTest()
{
await ExecuteAndVerifyResult("SELECT CAST('1:00:00.001' AS TIME)", "01:00:00.0010000");
}
[Test]
public async Task TimestampTest()
{
await ExecuteAndVerifyResult("SELECT CAST('A' AS TIMESTAMP)", "0x4100000000000000");
}
[Test]
public async Task TinyIntTest()
{
await ExecuteAndVerifyResult("SELECT CAST(1 AS TINYINT)", "1");
}
[Test]
public async Task UniqueIdentifierTest()
{
await ExecuteAndVerifyResult("SELECT CAST('fbf31d5b-bda2-4907-a50c-5458e95248ae' AS UNIQUEIDENTIFIER)", "fbf31d5b-bda2-4907-a50c-5458e95248ae");
}
[Test]
public async Task VarBinaryTest()
{
await ExecuteAndVerifyResult("SELECT CAST('ABCD' AS VARBINARY)", "0x41424344");
}
[Test]
public async Task VarCharTest()
{
await ExecuteAndVerifyResult("SELECT CAST('ABCD' AS VARCHAR)", "ABCD");
}
[Test]
public async Task XmlTest()
{
await ExecuteAndVerifyResult("SELECT CAST('<ABC>1234</ABC>' AS XML)", "<ABC>1234</ABC>");
}
private async Task ExecuteAndVerifyResult(string queryText, string expectedValue)
{
// Given a connection to a live database
var result = LiveConnectionHelper.InitLiveConnectionInfo();
ConnectionInfo connInfo = result.ConnectionInfo;
var fileStreamFactory = MemoryFileSystem.GetFileStreamFactory();
Query query = new Query(queryText, connInfo, new QueryExecutionSettings(), fileStreamFactory);
query.Execute();
query.ExecutionTask.Wait();
var subset = await query.GetSubset(0, 0, 0, 10);
Assert.AreEqual(1, subset.RowCount, "Row count does not match expected value.");
var actualValue = subset.Rows[0][0].DisplayValue;
Assert.AreEqual(expectedValue, actualValue);
}
}
}