public void Delete()
{
Guid TempGuid = Guid.NewGuid();
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter <string>("@StringValue1", "Test String");
Helper.AddParameter <string>("@StringValue2", "Test String");
Helper.AddParameter <long>("@BigIntValue", 12345);
Helper.AddParameter <bool>("@BitValue", true);
Helper.AddParameter <decimal>("@DecimalValue", 1234.5678m);
Helper.AddParameter <float>("@FloatValue", 12345.6534f);
Helper.AddParameter <Guid>("@GUIDValue", TempGuid);
Helper.AddParameter <DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("delete from TestTable where @ID=ID", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter <int>("@ID", 1);
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Fail("Nothing was deleted");
}
}
}
public void All()
{
Utilities.SQL.SQLHelper.Database("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_")
.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_");
ObjectClass1 TempObject = null;
Utilities.Random.Random Rand = new Utilities.Random.Random();
using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
{
for (int x = 0; x < 100; ++x)
{
TempObject = new ObjectClass1();
TempObject.StringValue = Rand.Next<string>(new RegexStringGenerator(10));
TempObject.BoolValue = Rand.Next<bool>();
TempObject.FloatValue = (float)Rand.NextDouble();
TempObject.LongValue =Rand.Next();
ORM.Save<ObjectClass1, int>(TempObject);
}
TempObject = null;
IEnumerable<ObjectClass1> Objects = ORM.All<ObjectClass1>();
Assert.Equal(100, Objects.Count());
}
}
public void CommandInsertNullString()
{
Guid TempGuid = Guid.NewGuid();
Utilities.SQL.Command TempCommand = new Utilities.SQL.Command("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@0,@1,@2,@3,@4,@5,@6,@7)", CommandType.Text, "Test String", null, 12345, true, 1234.5678m, 12345.6534f, new DateTime(1999, 12, 31), TempGuid);
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper(TempCommand, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false"))
{
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal("Test String", Helper.GetParameter <string>("StringValue1", ""));
Assert.Equal("This is a null string", Helper.GetParameter <string>("StringValue2", "This is a null string"));
Assert.Equal(12345, Helper.GetParameter <long>("BigIntValue", 0));
Assert.Equal(true, Helper.GetParameter <bool>("BitValue", false));
Assert.Equal(1234.5678m, Helper.GetParameter <decimal>("DecimalValue", 0));
Assert.Equal(12345.6534f, Helper.GetParameter <float>("FloatValue", 0));
Assert.Equal(TempGuid, Helper.GetParameter <Guid>("GUIDValue", Guid.Empty));
Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter <DateTime>("DateTimeValue", DateTime.Now));
}
else
{
Assert.False(true, "Nothing was inserted");
}
}
}
public void Delete()
{
using (Mapping <ObjectClass1> TestObject = new Mapping <ObjectClass1>("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", "TestTable", "ID_"))
{
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_", 100)
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_")
.Map(x => x.StringMaxValue, "StringMaxValue_", -1);
Utilities.Random.Random Rand = new Utilities.Random.Random();
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test";
TempObject.BoolValue = false;
TempObject.FloatValue = 1.5f;
TempObject.LongValue = 12;
TempObject.StringMaxValue = Rand.Next <string>(new RegexStringGenerator(6000));
TestObject.Save <int>(TempObject);
Assert.Equal(1, TestObject.Delete(TempObject));
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) AS ItemCount FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal(0, Helper.GetParameter <int>("ItemCount", -1));
}
else
{
Assert.False(true, "Nothing was inserted");
}
}
}
}
public void Insert()
{
using (Mapping <ObjectClass1> TestObject = new Mapping <ObjectClass1>("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", "TestTable", "ID_"))
{
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_", 100)
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_");
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test String";
TempObject.BoolValue = true;
TempObject.FloatValue = 1234.5f;
TempObject.LongValue = 12345;
TempObject.ID = TestObject.Insert <int>(TempObject);
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal("Test String", Helper.GetParameter <string>("StringValue_", ""));
Assert.Equal(1234.5f, Helper.GetParameter <float>("FloatValue_", 0));
Assert.Equal(true, Helper.GetParameter <bool>("BoolValue_", false));
Assert.Equal(12345, Helper.GetParameter <long>("LongValue_", 0));
Assert.Equal(TempObject.ID, Helper.GetParameter <int>("ID_", 0));
}
else
{
Assert.Fail("Nothing was inserted");
}
}
}
}
public void Creation()
{
Utilities.SQL.ParameterTypes.AndParameter TestObject = new Utilities.SQL.ParameterTypes.AndParameter(new EqualParameter <int>(1, "Left"), new EqualParameter <int>(2, "Right"));
Assert.Equal("(Left=@Left AND Right=@Right)", TestObject.ToString());
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Assert.DoesNotThrow(() => TestObject.AddParameter(Helper));
}
}
public void BulkCopy2()
{
Guid TempGuid = Guid.NewGuid();
List <BulkCopyObject> Objects = new List <BulkCopyObject>();
for (int x = 0; x < 100; ++x)
{
BulkCopyObject TempObject = new BulkCopyObject();
TempObject.BigIntValue = 12345;
TempObject.BitValue = true;
TempObject.DateTimeValue = new DateTime(1999, 12, 31);
TempObject.DecimalValue = 1234.5678m;
TempObject.FloatValue = 12345.6534f;
TempObject.GUIDValue = TempGuid;
TempObject.ID = x + 1;
TempObject.StringValue1 = "Test String";
TempObject.StringValue2 = "Test String";
Objects.Add(TempObject);
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteBulkCopy(Objects, "TestTable");
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
bool Inserted = false;
while (Helper.Read())
{
Inserted = true;
Assert.Equal("Test String", Helper.GetParameter <string>("StringValue1", ""));
Assert.Equal("Test String", Helper.GetParameter <string>("StringValue2", ""));
Assert.Equal(12345, Helper.GetParameter <long>("BigIntValue", 0));
Assert.Equal(true, Helper.GetParameter <bool>("BitValue", false));
Assert.Equal(1234.5678m, Helper.GetParameter <decimal>("DecimalValue", 0));
Assert.Equal(12345.6534f, Helper.GetParameter <float>("FloatValue", 0));
Assert.Equal(TempGuid, Helper.GetParameter <Guid>("GUIDValue", Guid.Empty));
Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter <DateTime>("DateTimeValue", DateTime.Now));
}
if (!Inserted)
{
Assert.False(true, "Nothing was inserted");
}
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) as [ItemCount] FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal(100, Helper.GetParameter <int>("ItemCount", 0));
}
else
{
Assert.False(true, "Nothing was inserted");
}
}
}
public void Connect()
{
Assert.DoesNotThrow <Exception>(() =>
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
}
});
}
public void Creation()
{
Utilities.SQL.ParameterTypes.OrParameter TestObject = new Utilities.SQL.ParameterTypes.OrParameter(new EqualParameter<int>(1, "Left"), new EqualParameter<int>(2, "Right"));
Assert.Equal("(Left=@Left OR Right=@Right)", TestObject.ToString());
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Assert.DoesNotThrow<Exception>(() => TestObject.AddParameter(Helper));
}
}
public void BulkCopy()
{
Guid TempGuid=Guid.NewGuid();
List<BulkCopyObject> Objects = new List<BulkCopyObject>();
for (int x = 0; x < 100; ++x)
{
BulkCopyObject TempObject = new BulkCopyObject();
TempObject.BigIntValue = 12345;
TempObject.BitValue = true;
TempObject.DateTimeValue = new DateTime(1999, 12, 31);
TempObject.DecimalValue = 1234.5678m;
TempObject.FloatValue = 12345.6534f;
TempObject.GUIDValue = TempGuid;
TempObject.ID = x+1;
TempObject.StringValue1 = "Test String";
TempObject.StringValue2 = "Test String";
Objects.Add(TempObject);
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteBulkCopy(Objects.ToDataTable(),"TestTable");
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
bool Inserted=false;
while (Helper.Read())
{
Inserted=true;
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue2", ""));
Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
}
if(!Inserted)
{
Assert.Fail("Nothing was inserted");
}
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) as [ItemCount] FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal(100, Helper.GetParameter<int>("ItemCount", 0));
}
else
{
Assert.Fail("Nothing was inserted");
}
}
}
public void Dispose()
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=master;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.Batch().AddCommand("ALTER DATABASE TestDatabase SET OFFLINE WITH ROLLBACK IMMEDIATE", CommandType.Text)
.AddCommand("ALTER DATABASE TestDatabase SET ONLINE", CommandType.Text)
.AddCommand("DROP DATABASE TestDatabase", CommandType.Text);
Helper.ExecuteNonQuery();
}
}
public Mapping()
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Database TestDatabase", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Table TestTable(ID_ INT PRIMARY KEY IDENTITY,StringValue_ NVARCHAR(100),LongValue_ BIGINT,BoolValue_ BIT,FloatValue_ FLOAT,StringMaxValue_ NVARCHAR(MAX))", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
}
}
public void Dispose()
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("ALTER DATABASE TestDatabase SET OFFLINE WITH ROLLBACK IMMEDIATE", "Data Source=localhost;Initial Catalog=master;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
Helper.Command = "ALTER DATABASE TestDatabase SET ONLINE";
Helper.ExecuteNonQuery();
Helper.Command = "DROP DATABASE TestDatabase";
Helper.ExecuteNonQuery();
}
}
public SQLHelper()
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Database TestDatabase", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Table TestTable(ID INT PRIMARY KEY IDENTITY,StringValue1 NVARCHAR(100),StringValue2 NVARCHAR(MAX),BigIntValue BIGINT,BitValue BIT,DecimalValue DECIMAL(12,6),FloatValue FLOAT,DateTimeValue DATETIME,GUIDValue UNIQUEIDENTIFIER)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
}
}
public void Creation()
{
Parameter<int> TestObject = new Parameter<int>(12, "ID");
Assert.Equal("ID", TestObject.ID);
Assert.Equal(12, TestObject.Value);
Assert.Equal("@", TestObject.ParameterStarter);
Assert.Equal("ID=@ID", TestObject.ToString());
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Assert.DoesNotThrow<Exception>(() => TestObject.AddParameter(Helper));
}
}
public SQLHelper()
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Database TestDatabase", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Table TestTable(ID INT PRIMARY KEY IDENTITY,StringValue1 NVARCHAR(100),StringValue2 NVARCHAR(MAX),BigIntValue BIGINT,BitValue BIT,DecimalValue DECIMAL(12,6),FloatValue FLOAT,DateTimeValue DATETIME,GUIDValue UNIQUEIDENTIFIER)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
}
}
public Mapping()
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Database TestDatabase", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("Create Table TestTable(ID_ INT PRIMARY KEY IDENTITY,StringValue_ NVARCHAR(100),LongValue_ BIGINT,BoolValue_ BIT,FloatValue_ FLOAT,StringMaxValue_ NVARCHAR(MAX))", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
}
}
public void Creation()
{
Utilities.SQL.ParameterTypes.LikeParameter TestObject = new Utilities.SQL.ParameterTypes.LikeParameter("ASDF", "ID", 100);
Assert.Equal("ID", TestObject.ID);
Assert.Equal("ASDF", TestObject.Value);
Assert.Equal("@", TestObject.ParameterStarter);
Assert.Equal("ID LIKE @ID", TestObject.ToString());
Assert.Equal(100, TestObject.Length);
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Assert.DoesNotThrow(() => TestObject.AddParameter(Helper));
}
}
public void Creation()
{
EqualParameter <int> TestObject = new EqualParameter <int>(12, "ID");
Assert.Equal("ID", TestObject.ID);
Assert.Equal(12, TestObject.Value);
Assert.Equal("@", TestObject.ParameterStarter);
Assert.Equal("ID=@ID", TestObject.ToString());
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Assert.DoesNotThrow(() => TestObject.AddParameter(Helper));
}
}
public void Creation()
{
Utilities.SQL.ParameterTypes.StringEqualParameter TestObject = new Utilities.SQL.ParameterTypes.StringEqualParameter("ASDF", "ID", 100);
Assert.Equal("ID", TestObject.ID);
Assert.Equal("ASDF", TestObject.Value);
Assert.Equal("@", TestObject.ParameterStarter);
Assert.Equal("ID=@ID", TestObject.ToString());
Assert.Equal(100, TestObject.Length);
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Assert.DoesNotThrow(() => Helper.AddParameter(TestObject));
}
}
public void Creation()
{
BetweenParameter<int> TestObject = new BetweenParameter<int>(10, 12, "ID");
Assert.Equal("ID", TestObject.ID);
Assert.Equal(10, TestObject.Min);
Assert.Equal(12, TestObject.Max);
Assert.Equal("@", TestObject.ParameterStarter);
Assert.Equal("ID BETWEEN @IDMin AND @IDMax", TestObject.ToString());
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Assert.DoesNotThrow(() => Helper.AddParameter(TestObject));
}
}
public void Update()
{
Guid TempGuid = Guid.NewGuid();
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter <string>("@StringValue1", "Test");
Helper.AddParameter <string>("@StringValue2", "Test");
Helper.AddParameter <long>("@BigIntValue", 123);
Helper.AddParameter <bool>("@BitValue", false);
Helper.AddParameter <decimal>("@DecimalValue", 1234);
Helper.AddParameter <float>("@FloatValue", 12345);
Helper.AddParameter <Guid>("@GUIDValue", Guid.NewGuid());
Helper.AddParameter <DateTime>("@DateTimeValue", new DateTime(1999, 1, 1));
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("update TestTable set StringValue1=@StringValue1,StringValue2=@StringValue2,BigIntValue=@BigIntValue,BitValue=@BitValue,DecimalValue=@DecimalValue,FloatValue=@FloatValue,DateTimeValue=@DateTimeValue,GUIDValue=@GUIDValue", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter <string>("@StringValue1", "Test String");
Helper.AddParameter <string>("@StringValue2", "Test String");
Helper.AddParameter <long>("@BigIntValue", 12345);
Helper.AddParameter <bool>("@BitValue", true);
Helper.AddParameter <decimal>("@DecimalValue", 1234.5678m);
Helper.AddParameter <float>("@FloatValue", 12345.6534f);
Helper.AddParameter <Guid>("@GUIDValue", TempGuid);
Helper.AddParameter <DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal("Test String", Helper.GetParameter <string>("StringValue1", ""));
Assert.Equal("Test String", Helper.GetParameter <string>("StringValue2", ""));
Assert.Equal(12345, Helper.GetParameter <long>("BigIntValue", 0));
Assert.Equal(true, Helper.GetParameter <bool>("BitValue", false));
Assert.Equal(1234.5678m, Helper.GetParameter <decimal>("DecimalValue", 0));
Assert.Equal(12345.6534f, Helper.GetParameter <float>("FloatValue", 0));
Assert.Equal(TempGuid, Helper.GetParameter <Guid>("GUIDValue", Guid.Empty));
Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter <DateTime>("DateTimeValue", DateTime.Now));
}
else
{
Assert.Fail("Nothing was inserted");
}
}
}
public void CreateDatabase()
{
Database Database = new Database("TestDatabase");
Table TestTable = Database.AddTable("TestTable");
TestTable.AddColumn<string>("ID_", DbType.Int32);
TestTable.AddColumn<string>("Value1", DbType.String, 100);
TestTable.AddColumn<string>("Value2", DbType.Double);
Utilities.SQL.SQLServer.SQLServer.CreateDatabase(Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(ID_,Value1,Value2) VALUES (@ID_,@Value1,@Value2)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter<int>("@ID_", 1);
Helper.AddParameter<string>("@Value1", "Test String");
Helper.AddParameter<float>("@Value2", 3.0f);
Assert.Equal(1, Helper.ExecuteNonQuery());
}
}
public void All()
{
using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_")
.Map(x => x.StringMaxValue, "StringMaxValue_");
Utilities.Random.Random Rand = new Utilities.Random.Random(12345);
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test String";
TempObject.BoolValue = true;
TempObject.FloatValue = 1234.5f;
TempObject.LongValue = 12345;
TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
Helper2.Save<ObjectClass1, int>(TempObject);
IEnumerable<ObjectClass1> Objects = Helper2.All<ObjectClass1>();
Assert.Equal(1, Objects.Count());
foreach (ObjectClass1 Item in Objects)
{
Assert.Equal("Test String", Item.StringValue);
Assert.Equal(1234.5f, Item.FloatValue);
Assert.Equal(true, Item.BoolValue);
Assert.Equal(12345, Item.LongValue);
Assert.Equal(1, Item.ID);
Assert.Equal(TempObject.StringMaxValue, Item.StringMaxValue);
}
List<ObjectClass1> Objects2 = new List<ObjectClass1>();
Rand = new Utilities.Random.Random();
for (int x = 0; x < 10; ++x)
{
TempObject = new ObjectClass1();
TempObject.StringValue = Rand.Next<string>(new RegexStringGenerator(10));
TempObject.BoolValue = Rand.Next<bool>();
TempObject.FloatValue = (float)Rand.NextDouble();
TempObject.LongValue = Rand.Next(0, 100);
TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
Objects2.Add(TempObject);
}
Helper2.Save<ObjectClass1, int>(Objects2);
Objects = Helper2.All<ObjectClass1>();
Assert.Equal(11, Objects.Count());
}
}
public void CreateDatabase()
{
Database Database = new Database("TestDatabase");
Table TestTable = Database.AddTable("TestTable");
TestTable.AddColumn <string>("ID_", DbType.Int32);
TestTable.AddColumn <string>("Value1", DbType.String, 100);
TestTable.AddColumn <string>("Value2", DbType.Double);
Utilities.SQL.SQLServer.SQLServer.CreateDatabase(Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(ID_,Value1,Value2) VALUES (@ID_,@Value1,@Value2)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter <int>("@ID_", 1);
Helper.AddParameter <string>("@Value1", "Test String");
Helper.AddParameter <float>("@Value2", 3.0f);
Assert.Equal(1, Helper.ExecuteNonQuery());
}
}
public void Creation()
{
Assert.DoesNotThrow(() =>
{
using (Mapping <ObjectClass1> TestObject = new Mapping <ObjectClass1>("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", "TestTable", "ID_"))
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
using (Mapping <ObjectClass1> TestObject2 = new Mapping <ObjectClass1>(TestObject, Helper))
{
}
}
}
using (Mapping <ObjectClass1> TestObject = new Mapping <ObjectClass1>("TestTable", "ID_"))
{
}
});
}
public void ClearParameters()
{
Guid TempGuid = Guid.NewGuid();
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter<string>("@StringValue1", "Test");
Helper.AddParameter<string>("@StringValue2", "Test");
Helper.AddParameter<long>("@BigIntValue", 123);
Helper.AddParameter<bool>("@BitValue", false);
Helper.AddParameter<decimal>("@DecimalValue", 1234);
Helper.AddParameter<float>("@FloatValue", 12345);
Helper.AddParameter<Guid>("@GUIDValue", Guid.NewGuid());
Helper.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 1, 1));
Helper.ClearParameters();
Helper.AddParameter<string>("@StringValue1", "Test String");
Helper.AddParameter<string>("@StringValue2", "Test String");
Helper.AddParameter<long>("@BigIntValue", 12345);
Helper.AddParameter<bool>("@BitValue", true);
Helper.AddParameter<decimal>("@DecimalValue", 1234.5678m);
Helper.AddParameter<float>("@FloatValue", 12345.6534f);
Helper.AddParameter<Guid>("@GUIDValue", TempGuid);
Helper.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue2", ""));
Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
}
else
{
Assert.Fail("Nothing was inserted");
}
}
}
public void OutputParamter()
{
Guid TempGuid = Guid.NewGuid();
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter <string>("@StringValue1", "Test String");
Helper.AddParameter <string>("@StringValue2", "Test String");
Helper.AddParameter <long>("@BigIntValue", 12345);
Helper.AddParameter <bool>("@BitValue", true);
Helper.AddParameter <decimal>("@DecimalValue", 1234.5678m);
Helper.AddParameter <float>("@FloatValue", 12345.6534f);
Helper.AddParameter <Guid>("@GUIDValue", TempGuid);
Helper.AddParameter <DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SET @ASD=12345", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter <long>("@ASD", Direction: ParameterDirection.Output);
Helper.ExecuteNonQuery();
Assert.Equal(12345, Helper.GetParameter <long>("@ASD", 0, ParameterDirection.Output));
}
}
public void UpdateDatabase()
{
Database Database = new Database("TestDatabase");
Table TestTable = Database.AddTable("TestTable");
TestTable.AddColumn <string>("ID_", DbType.Int32);
TestTable.AddColumn <string>("Value1", DbType.String, 100);
TestTable.AddColumn <string>("Value2", DbType.Double);
Utilities.SQL.SQLServer.SQLServer.CreateDatabase(Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
Database Database2 = new Database("TestDatabase");
TestTable = Database2.AddTable("TestTable");
TestTable.AddColumn <string>("ID_", DbType.Int32);
TestTable.AddColumn <string>("Value1", DbType.String, 100);
TestTable.AddColumn <string>("Value2", DbType.Double);
TestTable.AddColumn <string>("Value3", DbType.Boolean);
Utilities.SQL.SQLServer.SQLServer.UpdateDatabase(Database2, Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(ID_,Value1,Value2,Value3) VALUES (@ID_,@Value1,@Value2,@Value3)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter <int>("@ID_", 1);
Helper.AddParameter <string>("@Value1", "Test String");
Helper.AddParameter <float>("@Value2", 3.0f);
Helper.AddParameter <bool>("@Value3", true);
Assert.Equal(1, Helper.ExecuteNonQuery());
}
Database Database3 = Utilities.SQL.SQLServer.SQLServer.GetDatabaseStructure("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
Assert.Equal(Database2.Tables[0].Name, Database3.Tables[0].Name);
Assert.Equal(Database2.Tables[0].Columns.Count, Database3.Tables[0].Columns.Count);
Assert.Equal(DbType.Int32, Database3.Tables[0].Columns.First(x => x.Name == "ID_").DataType);
Assert.Equal(DbType.String, Database3.Tables[0].Columns.First(x => x.Name == "Value1").DataType);
Assert.Equal(DbType.Double, Database3.Tables[0].Columns.First(x => x.Name == "Value2").DataType);
Assert.Equal(100, Database3.Tables[0].Columns.First(x => x.Name == "Value1").Length);
Assert.Equal(4, Database3.Tables[0].Columns.First(x => x.Name == "ID_").Length);
Assert.Equal(8, Database3.Tables[0].Columns.First(x => x.Name == "Value2").Length);
}
public void OutputParamter()
{
Guid TempGuid = Guid.NewGuid();
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter<string>("@StringValue1", "Test String");
Helper.AddParameter<string>("@StringValue2", "Test String");
Helper.AddParameter<long>("@BigIntValue", 12345);
Helper.AddParameter<bool>("@BitValue", true);
Helper.AddParameter<decimal>("@DecimalValue", 1234.5678m);
Helper.AddParameter<float>("@FloatValue", 12345.6534f);
Helper.AddParameter<Guid>("@GUIDValue", TempGuid);
Helper.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SET @ASD=12345", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter<long>("@ASD", Direction: ParameterDirection.Output);
Helper.ExecuteNonQuery();
Assert.Equal(12345, Helper.GetParameter<long>("@ASD", 0, ParameterDirection.Output));
}
}
public void CommandInsertNullString()
{
Guid TempGuid = Guid.NewGuid();
Utilities.SQL.Command TempCommand = new Utilities.SQL.Command("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@0,@1,@2,@3,@4,@5,@6,@7)", CommandType.Text, "Test String", null, 12345, true, 1234.5678m, 12345.6534f, new DateTime(1999, 12, 31), TempGuid);
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper(TempCommand, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false"))
{
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
Assert.Equal("This is a null string", Helper.GetParameter<string>("StringValue2", "This is a null string"));
Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
}
else
{
Assert.Fail("Nothing was inserted");
}
}
}
public void CachedQuery()
{
Guid TempGuid = Guid.NewGuid();
for (int x = 0; x < 100; ++x)
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter<string>("@StringValue1", "Test String")
.AddParameter<string>("@StringValue2", "Test String")
.AddParameter<long>("@BigIntValue", 12345)
.AddParameter<bool>("@BitValue", true)
.AddParameter<decimal>("@DecimalValue", 1234.5678m)
.AddParameter<float>("@FloatValue", 12345.6534f)
.AddParameter<Guid>("@GUIDValue", TempGuid)
.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 12, 31))
.ExecuteNonQuery();
}
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader(Cache: true);
int Count=0;
while (Helper.Read())
{
++Count;
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue2", ""));
Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
}
Assert.Equal(100, Count);
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader(Cache: true);
int Count = 0;
while (Helper.Read())
{
++Count;
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue1", ""));
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue2", ""));
Assert.Equal(12345, Helper.GetParameter<long>("BigIntValue", 0));
Assert.Equal(true, Helper.GetParameter<bool>("BitValue", false));
Assert.Equal(1234.5678m, Helper.GetParameter<decimal>("DecimalValue", 0));
Assert.Equal(12345.6534f, Helper.GetParameter<float>("FloatValue", 0));
Assert.Equal(TempGuid, Helper.GetParameter<Guid>("GUIDValue", Guid.Empty));
Assert.Equal(new DateTime(1999, 12, 31), Helper.GetParameter<DateTime>("DateTimeValue", DateTime.Now));
}
Assert.Equal(100, Count);
}
}
public void Update()
{
using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_")
.Map(x => x.StringMaxValue, "StringMaxValue_");
Utilities.Random.Random Rand = new Utilities.Random.Random(12346);
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test";
TempObject.BoolValue = false;
TempObject.FloatValue = 1.5f;
TempObject.LongValue = 12;
TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
TempObject.ID = Helper2.Insert<ObjectClass1, int>(TempObject);
Rand = new Utilities.Random.Random(12345);
TempObject.StringValue = "Test String";
TempObject.BoolValue = true;
TempObject.FloatValue = 1234.5f;
TempObject.LongValue = 12345;
TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
Helper2.Update(TempObject);
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue_", ""));
Assert.Equal(1234.5f, Helper.GetParameter<float>("FloatValue_", 0));
Assert.Equal(true, Helper.GetParameter<bool>("BoolValue_", false));
Assert.Equal(12345, Helper.GetParameter<long>("LongValue_", 0));
Assert.Equal(TempObject.ID, Helper.GetParameter<int>("ID_", 0));
Assert.Equal(TempObject.StringMaxValue, Helper.GetParameter<string>("StringMaxValue_", ""));
}
else
{
Assert.False(true,"Nothing was inserted");
}
}
}
}
public void Scalar()
{
using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_")
.Map(x => x.StringMaxValue, "StringMaxValue_");
Utilities.Random.Random Rand = new Utilities.Random.Random(12345);
for (int x = 0; x < 100; ++x)
{
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test String";
TempObject.BoolValue = true;
TempObject.FloatValue = 1234.5f;
TempObject.LongValue = 12345;
TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
string StringMaxValue = TempObject.StringMaxValue;
Helper2.Save<ObjectClass1, int>(TempObject);
}
int ASD = Helper2.Scalar<ObjectClass1, int>("SELECT COUNT(*) FROM TestTable", CommandType.Text);
Assert.Equal(100, ASD);
ASD = Helper2.Scalar<ObjectClass1, int>("COUNT(*)");
Assert.Equal(100, ASD);
}
}
public void Paged2()
{
using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_")
.Map(x => x.StringMaxValue, "StringMaxValue_");
List<ObjectClass1> Objects2 = new List<ObjectClass1>();
Utilities.Random.Random Rand = new Utilities.Random.Random();
for (int x = 0; x < 115; ++x)
{
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = Rand.Next<string>(new RegexStringGenerator(10));
TempObject.BoolValue = Rand.Next<bool>();
TempObject.FloatValue = (float)Rand.NextDouble();
TempObject.LongValue = Rand.Next(0, 100);
TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
Objects2.Add(TempObject);
}
Helper2.Save<ObjectClass1, int>(Objects2);
IEnumerable<ObjectClass1> Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable");
Assert.Equal(25, Objects.Count());
Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable", CurrentPage: 1);
Assert.Equal(25, Objects.Count());
Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable", CurrentPage: 2);
Assert.Equal(25, Objects.Count());
Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable", CurrentPage: 3);
Assert.Equal(25, Objects.Count());
Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable", CurrentPage: 4);
Assert.Equal(15, Objects.Count());
Assert.Equal(5, Helper2.PageCount<ObjectClass1>("SELECT * FROM TestTable"));
Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable WHERE ID_>@ID", "", 25, 0, null, null, false, new EqualParameter<int>(50, "ID"));
Assert.Equal(25, Objects.Count());
Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable WHERE ID_>@ID", "", 25, 1, null, null, false, new EqualParameter<int>(50, "ID"));
Assert.Equal(25, Objects.Count());
Objects = Helper2.PagedCommand<ObjectClass1>("SELECT * FROM TestTable WHERE ID_>@ID", "", 25, 2, null, null, false, new EqualParameter<int>(50, "ID"));
Assert.Equal(15, Objects.Count());
Assert.Equal(3, Helper2.PageCount<ObjectClass1>("SELECT * FROM TestTable WHERE ID_>@ID", 25, false, new EqualParameter<int>(50, "ID")));
}
}
public void Delete()
{
using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("","Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false",CommandType.Text))
{
Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_")
.Map(x => x.StringMaxValue, "StringMaxValue_");
Utilities.Random.Random Rand = new Utilities.Random.Random();
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test";
TempObject.BoolValue = false;
TempObject.FloatValue = 1.5f;
TempObject.LongValue = 12;
TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
Helper2.Save<ObjectClass1, int>(TempObject);
Assert.Equal(1, Helper2.Delete<ObjectClass1>(TempObject));
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) AS ItemCount FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal(0, Helper.GetParameter<int>("ItemCount", -1));
}
else
{
Assert.False(true,"Nothing was inserted");
}
}
}
}
public void Creation()
{
Assert.DoesNotThrow(() =>
{
Mapping<ObjectClass1> TestObject = new Mapping<ObjectClass1>("TestTable", "ID_");
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Mapping<ObjectClass1> TestObject2 = new Mapping<ObjectClass1>(TestObject);
}
TestObject = new Mapping<ObjectClass1>("TestTable", "ID_");
});
}
public void Delete()
{
Guid TempGuid = Guid.NewGuid();
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(StringValue1,StringValue2,BigIntValue,BitValue,DecimalValue,FloatValue,DateTimeValue,GUIDValue) VALUES (@StringValue1,@StringValue2,@BigIntValue,@BitValue,@DecimalValue,@FloatValue,@DateTimeValue,@GUIDValue)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter<string>("@StringValue1", "Test String");
Helper.AddParameter<string>("@StringValue2", "Test String");
Helper.AddParameter<long>("@BigIntValue", 12345);
Helper.AddParameter<bool>("@BitValue", true);
Helper.AddParameter<decimal>("@DecimalValue", 1234.5678m);
Helper.AddParameter<float>("@FloatValue", 12345.6534f);
Helper.AddParameter<Guid>("@GUIDValue", TempGuid);
Helper.AddParameter<DateTime>("@DateTimeValue", new DateTime(1999, 12, 31));
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("delete from TestTable where @ID=ID", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter<int>("@ID", 1);
Helper.ExecuteNonQuery();
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Fail("Nothing was deleted");
}
}
}
public void Save()
{
Utilities.SQL.SQLHelper.Database("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable","ID_")
.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_");
ObjectClass1 TempObject = new ObjectClass1();
using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
{
TempObject.StringValue = "Test";
TempObject.BoolValue = false;
TempObject.FloatValue = 1.5f;
TempObject.LongValue = 12;
ORM.Save<ObjectClass1, int>(TempObject);
TempObject.StringValue = "Test String";
TempObject.BoolValue = true;
TempObject.FloatValue = 1234.5f;
TempObject.LongValue = 12345;
ORM.Save<ObjectClass1,int>(TempObject);
}
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT * FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal("Test String", Helper.GetParameter<string>("StringValue_", ""));
Assert.Equal(1234.5f, Helper.GetParameter<float>("FloatValue_", 0));
Assert.Equal(true, Helper.GetParameter<bool>("BoolValue_", false));
Assert.Equal(12345, Helper.GetParameter<long>("LongValue_", 0));
Assert.Equal(TempObject.ID, Helper.GetParameter<int>("ID_", 0));
}
else
{
Assert.False(true,"Nothing was inserted");
}
}
}
public void Dispose()
{
Utilities.SQL.MicroORM.MicroORM.ClearAllMappings();
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("ALTER DATABASE TestDatabase SET OFFLINE WITH ROLLBACK IMMEDIATE", "Data Source=localhost;Initial Catalog=master;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteNonQuery();
Helper.Command = "ALTER DATABASE TestDatabase SET ONLINE";
Helper.ExecuteNonQuery();
Helper.Command = "DROP DATABASE TestDatabase";
Helper.ExecuteNonQuery();
}
}
public void AnyDifferentParameterTypes()
{
Utilities.SQL.SQLHelper.Database("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_")
.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_");
for (int x = 0; x < 30; ++x)
{
using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
{
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test String";
TempObject.BoolValue = true;
TempObject.FloatValue = 1234.5f;
TempObject.LongValue = x;
TempObject.ID = ORM.Insert<ObjectClass1, int>(TempObject);
}
}
using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
{
ObjectClass1 TempObject = ORM.Any<ObjectClass1>("*", null, null, false, new EqualParameter<long>(20, "LongValue_"));
Assert.Equal(21, TempObject.ID);
Assert.Equal(20, TempObject.LongValue);
IEnumerable<ObjectClass1> TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new NotEqualParameter<long>(20, "LongValue_"));
Assert.Equal(29, TempObjects.Count());
TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new BetweenParameter<long>(20, 25, "LongValue_"));
Assert.Equal(6, TempObjects.Count());
TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new AndParameter(new BetweenParameter<long>(20, 25, "LongValue_"), new NotEqualParameter<long>(20, "LongValue_")));
Assert.Equal(5, TempObjects.Count());
TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new OrParameter(new BetweenParameter<long>(20, 25, "LongValue_"), new EqualParameter<long>(29, "LongValue_")));
Assert.Equal(7, TempObjects.Count());
TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new LikeParameter("Test%", "StringValue_", 100));
Assert.Equal(30, TempObjects.Count());
TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new LikeParameter("Test2%", "StringValue_", 100));
Assert.Equal(0, TempObjects.Count());
TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null, false, new StringEqualParameter("Test String", "StringValue_", 100));
Assert.Equal(30, TempObjects.Count());
TempObjects = ORM.All<ObjectClass1>("*", 0, "", null, null,false, new StringNotEqualParameter("Test String", "StringValue_", 100));
Assert.Equal(0, TempObjects.Count());
}
}
public void Delete()
{
using (Mapping<ObjectClass1> TestObject = new Mapping<ObjectClass1>("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", "TestTable", "ID_"))
{
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_", 100)
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_");
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test";
TempObject.BoolValue = false;
TempObject.FloatValue = 1.5f;
TempObject.LongValue = 12;
TestObject.Save<int>(TempObject);
Assert.Equal(1, TestObject.Delete(TempObject));
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("SELECT COUNT(*) AS ItemCount FROM TestTable", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.ExecuteReader();
if (Helper.Read())
{
Assert.Equal(0, Helper.GetParameter<int>("ItemCount", -1));
}
else
{
Assert.Fail("Nothing was inserted");
}
}
}
}
public void Connect()
{
Assert.DoesNotThrow<Exception>(() =>
{
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
}
});
}
public void UpdateDatabase()
{
Database Database = new Database("TestDatabase");
Table TestTable = Database.AddTable("TestTable");
TestTable.AddColumn<string>("ID_", DbType.Int32);
TestTable.AddColumn<string>("Value1", DbType.String, 100);
TestTable.AddColumn<string>("Value2", DbType.Double);
Utilities.SQL.SQLServer.SQLServer.CreateDatabase(Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
Database Database2 = new Database("TestDatabase");
TestTable = Database2.AddTable("TestTable");
TestTable.AddColumn<string>("ID_", DbType.Int32);
TestTable.AddColumn<string>("Value1", DbType.String, 100);
TestTable.AddColumn<string>("Value2", DbType.Double);
TestTable.AddColumn<string>("Value3", DbType.Boolean);
Utilities.SQL.SQLServer.SQLServer.UpdateDatabase(Database2, Database, "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
using (Utilities.SQL.SQLHelper Helper = new Utilities.SQL.SQLHelper("insert into TestTable(ID_,Value1,Value2,Value3) VALUES (@ID_,@Value1,@Value2,@Value3)", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Helper.AddParameter<int>("@ID_", 1);
Helper.AddParameter<string>("@Value1", "Test String");
Helper.AddParameter<float>("@Value2", 3.0f);
Helper.AddParameter<bool>("@Value3", true);
Assert.Equal(1, Helper.ExecuteNonQuery());
}
Database Database3 = Utilities.SQL.SQLServer.SQLServer.GetDatabaseStructure("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
Assert.Equal(Database2.Tables.First().Name, Database3.Tables.First().Name);
Assert.Equal(Database2.Tables.First().Columns.Count, Database3.Tables.First().Columns.Count);
Assert.Equal(DbType.Int32, Database3.Tables.First().Columns.First(x => x.Name == "ID_").DataType);
Assert.Equal(DbType.String, Database3.Tables.First().Columns.First(x => x.Name == "Value1").DataType);
Assert.Equal(DbType.Double, Database3.Tables.First().Columns.First(x => x.Name == "Value2").DataType);
Assert.Equal(100, Database3.Tables.First().Columns.First(x => x.Name == "Value1").Length);
Assert.Equal(4, Database3.Tables.First().Columns.First(x => x.Name == "ID_").Length);
Assert.Equal(8, Database3.Tables.First().Columns.First(x => x.Name == "Value2").Length);
}
public void Any()
{
Utilities.SQL.SQLHelper.Database("Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false");
Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_")
.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_");
ObjectClass1 TempObject = new ObjectClass1();
using (Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper())
{
TempObject.StringValue = "Test String";
TempObject.BoolValue = true;
TempObject.FloatValue = 1234.5f;
TempObject.LongValue = 12345;
ORM.Save<ObjectClass1,int>(TempObject);
TempObject = null;
TempObject = ORM.Any<ObjectClass1>();
Assert.Equal("Test String", TempObject.StringValue);
Assert.Equal(1234.5f, TempObject.FloatValue);
Assert.Equal(true, TempObject.BoolValue);
Assert.Equal(12345, TempObject.LongValue);
Assert.Equal(1, TempObject.ID);
}
}
public void Creation()
{
Assert.DoesNotThrow(() => { Utilities.SQL.SQLHelper ORM = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text); });
}
public void Any()
{
using (Utilities.SQL.SQLHelper Helper2 = new Utilities.SQL.SQLHelper("", "Data Source=localhost;Initial Catalog=TestDatabase;Integrated Security=SSPI;Pooling=false", CommandType.Text))
{
Mapping<ObjectClass1> TestObject = Utilities.SQL.SQLHelper.Map<ObjectClass1>("TestTable", "ID_");
TestObject.Map(x => x.ID, "ID_")
.Map(x => x.StringValue, "StringValue_")
.Map(x => x.FloatValue, "FloatValue_")
.Map(x => x.BoolValue, "BoolValue_")
.Map(x => x.LongValue, "LongValue_")
.Map(x => x.StringMaxValue, "StringMaxValue_");
Utilities.Random.Random Rand = new Utilities.Random.Random(12345);
ObjectClass1 TempObject = new ObjectClass1();
TempObject.StringValue = "Test String";
TempObject.BoolValue = true;
TempObject.FloatValue = 1234.5f;
TempObject.LongValue = 12345;
TempObject.StringMaxValue = Rand.Next<string>(new RegexStringGenerator(6000));
string StringMaxValue = TempObject.StringMaxValue;
Helper2.Save<ObjectClass1, int>(TempObject);
TempObject = Helper2.Any<ObjectClass1>();
Assert.Equal("Test String", TempObject.StringValue);
Assert.Equal(1234.5f, TempObject.FloatValue);
Assert.Equal(true, TempObject.BoolValue);
Assert.Equal(12345, TempObject.LongValue);
Assert.Equal(1, TempObject.ID);
Assert.Equal(StringMaxValue, TempObject.StringMaxValue);
}
}
