public static void CompareSimpleStrings(string s1, string s2, int expected)
{
var sqlString1 = new SqlString(s1);
var sqlString2 = new SqlString(s2);
var type = PrimitiveTypes.String();
Assert.True(type.IsComparable(type));
var result = type.Compare(sqlString1, sqlString2);
Assert.Equal(expected, result);
}
public void CreateSimple_RegularUser()
{
var tableName = ObjectName.Parse("APP.test_table");
var tableInfo = new TableInfo(tableName);
tableInfo.AddColumn("a", PrimitiveTypes.Integer(), true);
tableInfo.AddColumn("b", PrimitiveTypes.String());
using (var session = CreateUserSession(TestUserName, TestPassword)) {
using (var query = session.CreateQuery()) {
Assert.DoesNotThrow(() => query.CreateTable(tableInfo));
}
}
}
public static void SerializeValue(string s)
{
ISqlValue value = String.IsNullOrEmpty(s) ? (ISqlValue)SqlNull.Value : new SqlString(s);
var type = PrimitiveTypes.String();
var stream = new MemoryStream();
type.Serialize(stream, value);
stream.Seek(0, SeekOrigin.Begin);
var result = type.Deserialize(stream);
Assert.Equal(value, result);
}
protected override ISession CreateAdminSession(IDatabase database)
{
using (var session = base.CreateAdminSession(database)) {
using (var query = session.CreateQuery()) {
var tableInfo = new TableInfo(ObjectName.Parse("APP.test_table"));
tableInfo.AddColumn("a", PrimitiveTypes.Integer());
tableInfo.AddColumn("b", PrimitiveTypes.String(), false);
query.CreateTable(tableInfo, false, false);
query.Commit();
}
}
return(base.CreateAdminSession(database));
}
protected override ISession CreateAdminSession(IDatabase database)
{
using (var session = base.CreateAdminSession(database)) {
using (var query = session.CreateQuery()) {
var tableInfo = new TableInfo(ObjectName.Parse("APP.people"));
tableInfo.AddColumn("id", PrimitiveTypes.BigInt());
tableInfo.AddColumn("first_name", PrimitiveTypes.String(), true);
tableInfo.AddColumn("last_name", PrimitiveTypes.String());
tableInfo.AddColumn("age", PrimitiveTypes.TinyInt());
query.CreateTable(tableInfo);
query.Commit();
}
}
return(base.CreateAdminSession(database));
}
public void TestSetUp()
{
var tableInfo = new TableInfo(new ObjectName("test_table"));
tableInfo.AddColumn("id", PrimitiveTypes.Numeric());
tableInfo.AddColumn("name", PrimitiveTypes.String());
tableInfo.AddColumn("date", PrimitiveTypes.DateTime());
var cornerTime = DateTimeOffset.UtcNow;
var tmpTable = new TemporaryTable(tableInfo);
AddRow(tmpTable, 1, "test1", cornerTime);
AddRow(tmpTable, 2, "test2", cornerTime.AddSeconds(2));
AddRow(tmpTable, 3, "test3", cornerTime.AddSeconds(5));
tmpTable.BuildIndexes();
table = tmpTable;
}
public void CreateSimpleTableAsAdmin_NewSession()
{
var tableName = ObjectName.Parse("APP.test_table");
var tableInfo = new TableInfo(tableName);
tableInfo.AddColumn("a", PrimitiveTypes.Integer(), true);
tableInfo.AddColumn("b", PrimitiveTypes.String());
using (var session = CreateUserSession(AdminUserName, AdminPassword)) {
using (var query = session.CreateQuery()) {
Assert.DoesNotThrow(() => query.CreateTable(tableInfo));
Assert.DoesNotThrow(() => query.Commit());
}
}
using (var session = CreateUserSession(AdminUserName, AdminPassword)) {
using (var query = session.CreateQuery()) {
bool exists = false;
Assert.DoesNotThrow(() => exists = query.TableExists(tableName));
Assert.IsTrue(exists);
}
}
}
public static SqlType Deserialize(BinaryReader reader, ISqlTypeResolver typeResolver)
{
var typeCode = (SqlTypeCode)reader.ReadByte();
if (SqlBooleanType.IsBooleanType(typeCode))
{
return(PrimitiveTypes.Boolean(typeCode));
}
if (SqlDateTimeType.IsDateType(typeCode))
{
return(PrimitiveTypes.DateTime(typeCode));
}
if (typeCode == SqlTypeCode.DayToSecond)
{
return(PrimitiveTypes.DayToSecond());
}
if (typeCode == SqlTypeCode.YearToMonth)
{
return(PrimitiveTypes.YearToMonth());
}
if (SqlCharacterType.IsStringType(typeCode))
{
var maxSize = reader.ReadInt32();
CultureInfo locale = null;
var hasLocale = reader.ReadByte() == 1;
if (hasLocale)
{
var name = reader.ReadString();
locale = new CultureInfo(name);
}
return(PrimitiveTypes.String(typeCode, maxSize, locale));
}
if (SqlNumericType.IsNumericType(typeCode))
{
var size = reader.ReadInt32();
var scale = reader.ReadInt32();
return(PrimitiveTypes.Numeric(typeCode, size, scale));
}
if (SqlBinaryType.IsBinaryType(typeCode))
{
var size = reader.ReadInt32();
return(PrimitiveTypes.Binary(typeCode, size));
}
if (typeCode == SqlTypeCode.Type)
{
if (typeResolver == null)
{
throw new NotSupportedException("User-Defined types require a resolver context.");
}
// TODO: support type arguments
var typeName = reader.ReadString();
return(typeResolver.Resolve(new SqlTypeResolveInfo(typeName)));
}
/*
* TODO:
* if (typeCode == SqlTypeCode.QueryPlan)
* return new SqlQueryType();
*/
if (typeCode == SqlTypeCode.Array)
{
var size = reader.ReadInt32();
return(new SqlArrayType(size));
}
throw new NotSupportedException($"The type code '{typeCode}' does not support deserialization");
}
public static SqlObject String(SqlString value)
{
return(new SqlObject(PrimitiveTypes.String(), value));
}
public static Field Create(object value)
{
// Numeric values ...
if (value is bool)
{
return(Boolean((bool)value));
}
if (value is byte)
{
return(TinyInt((byte)value));
}
if (value is short)
{
return(SmallInt((short)value));
}
if (value is int)
{
return(Integer((int)value));
}
if (value is long)
{
return(BigInt((long)value));
}
if (value is float)
{
return(Float((float)value));
}
if (value is double)
{
return(Double((double)value));
}
if (value is SqlNumber)
{
var num = (SqlNumber)value;
if (num.IsNull)
{
return(Null(PrimitiveTypes.Numeric()));
}
if (num.CanBeInt32)
{
return(Integer(num.ToInt32()));
}
if (num.CanBeInt64)
{
return(BigInt(num.ToInt64()));
}
return(Number(num));
}
if (value is SqlDateTime)
{
return(Date((SqlDateTime)value));
}
if (value is DateTime)
{
return(Date((DateTime)value));
}
if (value is DateTimeOffset)
{
return(Date((DateTimeOffset)value));
}
// String values ...
if (value is string)
{
return(String((string)value));
}
if (value is SqlString)
{
var s = (SqlString)value;
if (s.IsNull)
{
return(Null(PrimitiveTypes.String()));
}
return(String(s));
}
if (value is SqlLongString)
{
var clob = (SqlLongString)value;
if (clob.IsNull)
{
return(Null(PrimitiveTypes.Clob()));
}
return(Clob(clob));
}
if (value == null)
{
return(Null());
}
// Trivial case
if (value is Field)
{
return((Field)value);
}
throw new NotSupportedException("Cannot build an object from the given value.");
}
public static Field VarChar(SqlString s)
{
return(new Field(PrimitiveTypes.String(SqlTypeCode.VarChar), s));
}
public static Field String(SqlString s)
{
return(new Field(PrimitiveTypes.String(SqlTypeCode.String), s));
}
public Field AsVarChar()
{
return(CastTo(PrimitiveTypes.String(SqlTypeCode.VarChar)));
}
public static SqlType FromValue(object value)
{
if (value is SqlNumber)
{
var number = (SqlNumber)value;
if (number.Scale == 0)
{
if (number.Precision <= 3)
{
return(PrimitiveTypes.TinyInt());
}
if (number.Precision <= 5)
{
return(PrimitiveTypes.SmallInt());
}
if (number.Precision <= 10)
{
return(PrimitiveTypes.Integer());
}
if (number.Precision <= 19)
{
return(PrimitiveTypes.BigInt());
}
}
else
{
if (number.Precision <= 8)
{
return(PrimitiveTypes.Float());
}
if (number.Precision <= 12)
{
return(PrimitiveTypes.Double());
}
return(PrimitiveTypes.Numeric(number.Precision, number.Scale));
}
}
if (value is SqlBoolean)
{
return(PrimitiveTypes.Boolean());
}
if (value is bool)
{
return(PrimitiveTypes.Boolean());
}
if (value is double)
{
return(PrimitiveTypes.Double());
}
if (value is float)
{
return(PrimitiveTypes.Float());
}
if (value is int)
{
return(PrimitiveTypes.Integer());
}
if (value is long)
{
return(PrimitiveTypes.BigInt());
}
if (value is byte)
{
return(PrimitiveTypes.TinyInt());
}
if (value is short)
{
return(PrimitiveTypes.SmallInt());
}
if (value is string)
{
return(PrimitiveTypes.String());
}
throw new NotSupportedException();
}
public void DeclareVariable()
{
Query.DeclareVariable("a", PrimitiveTypes.String());
}
