private static IEnumerable <TestCaseData> NonQueryProcedureCases()
{
yield return(new TestCaseData(
TSql.NonQueryProcedure("text"),
new SqlNonQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedure("text", parameters: null),
new SqlNonQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedure("text", new { }),
new SqlNonQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedure("text", new { Parameter = new SqlParameterValueStub() }),
new SqlNonQueryCommand("text", new[]
{
new SqlParameterValueStub().ToDbParameter("@Parameter")
}, CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedure("text", new { Parameter1 = new SqlParameterValueStub(), Parameter2 = new SqlParameterValueStub() }),
new SqlNonQueryCommand("text", new[]
{
new SqlParameterValueStub().ToDbParameter("@Parameter1"),
new SqlParameterValueStub().ToDbParameter("@Parameter2")
}, CommandType.StoredProcedure)));
}
private void DispatchCommands()
{
if (!_isLive || Interlocked.CompareExchange(ref _isDispatching, 1, 0) != 0)
{
return;
}
var candidates = Enumerable.Repeat(new { Id = default(Guid), CausationId = default(Guid) }, 0).ToList();
using (var reader = _queryExecutor.ExecuteReader(TSql.QueryStatement(@"SELECT [Id], [CausationId] FROM [ApprovalProcess] WHERE [DispatchAcknowledged] = 0 AND ([Dispatched] IS NULL OR [Dispatched] < DATEADD(MINUTE, -5, GETDATE()))")))
{
candidates = reader.Cast <IDataRecord>()
.Select(record => new { Id = record.GetGuid(0), CausationId = record.GetGuid(1) })
.ToList();
}
foreach (var candidate in candidates)
{
var newCausationId = ApprovalProcessorConstants.DeterministicGuid.Create(candidate.CausationId);
_bus.Publish(new MarkApprovalAccepted
{
Id = candidate.Id,
ReferenceNumber = GuidEncoder.Encode(candidate.CausationId)
}, context => context.SetHeader(Constants.CausationIdKey, newCausationId.ToString()));
_queryExecutor.ExecuteNonQuery(TSql.NonQueryStatement(@"UPDATE [ApprovalProcess] SET [Dispatched] = GETDATE() WHERE [Id] = @P1", new { P1 = TSql.UniqueIdentifier(candidate.Id) }));
}
Interlocked.Exchange(ref _isDispatching, 0);
}
public void ComposeCommandArrayReturnsComposer()
{
Assert.IsInstanceOf <SqlNonQueryCommandComposer>(
TSql.Compose(
CommandFactory(),
CommandFactory()));
}
static void Main(string[] args)
{
Benchmark.Begin += (name, id) =>
{
using (ConsoleUtil.Color(fg: ConsoleColor.Green))
Console.WriteLine("{0}:{1}->{2}", id, name, DateTime.Now);
};
Benchmark.End += (name, id, elapse) =>
{
using (ConsoleUtil.Color(fg: ConsoleColor.Green))
Console.WriteLine("{0}:{1}->{2}ms, {3}", id, name, elapse, DateTime.Now);
};
using (Benchmark.Start("*"))
{
try
{
List <IStatement> ast;
using (Benchmark.Start("parse"))
ast = TSql.ParseFile("Test.sql").ToList();
using (Benchmark.Start("analyze"))
Analyze(ast);
}
catch (Exception e)
{
using (ConsoleUtil.Color(ConsoleColor.Red))
Console.WriteLine(e.Message);
}
}
Console.WriteLine("Press any key to quit...");
Console.ReadKey(true);
}
private static IEnumerable <TestCaseData> QueryStatementCases()
{
yield return(new TestCaseData(
TSql.QueryStatement("text"),
new SqlQueryCommand("text", new DbParameter[0], CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatement("text", parameters: null),
new SqlQueryCommand("text", new DbParameter[0], CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatement("text", new { }),
new SqlQueryCommand("text", new DbParameter[0], CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatement("text", new { Parameter = new SqlParameterValueStub() }),
new SqlQueryCommand("text", new[]
{
new SqlParameterValueStub().ToDbParameter("@Parameter")
}, CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatement("text", new { Parameter1 = new SqlParameterValueStub(), Parameter2 = new SqlParameterValueStub() }),
new SqlQueryCommand("text", new[]
{
new SqlParameterValueStub().ToDbParameter("@Parameter1"),
new SqlParameterValueStub().ToDbParameter("@Parameter2")
}, CommandType.Text)));
}
public static IEnumerable <object> Handle(ItemPurchased purchased)
{
yield return(TSql.NonQueryStatement(@"insert into ItemsPurchased (StockKeepingUnit) values (@StockKeepingUnit)", new
{
purchased.StockKeepingUnit
}));
}
public void ComposeIfCommandArrayReturnsComposer([Values(true, false)] bool condition)
{
Assert.IsInstanceOf <SqlNonQueryCommandComposer>(
TSql.ComposeIf(
condition,
CommandFactory(),
CommandFactory()));
}
public void ComposeUnlessCommandEnumerationReturnsComposer([Values(true, false)] bool condition)
{
Assert.IsInstanceOf <SqlNonQueryCommandComposer>(
TSql.ComposeUnless(condition, (IEnumerable <SqlNonQueryCommand>) new[]
{
CommandFactory(),
CommandFactory()
}));
}
public void ComposedUnlessCommandArrayIsNotPreservedAndReturnedByComposerWhenConditionIsTrue()
{
var command1 = CommandFactory();
var command2 = CommandFactory();
SqlNonQueryCommand[] result = TSql.ComposeUnless(true, command1, command2);
Assert.That(result, Is.EquivalentTo(new SqlNonQueryCommand[0]));
}
public void ComposeCommandEnumerationReturnsComposer()
{
Assert.IsInstanceOf <SqlNonQueryCommandComposer>(
TSql.Compose((IEnumerable <SqlNonQueryCommand>) new[]
{
CommandFactory(),
CommandFactory()
}));
}
private static IEnumerable <TestCaseData> NonQueryStatementIfCases()
{
yield return(new TestCaseData(
TSql.NonQueryStatementIf(true, "text"),
new[] { new SqlNonQueryCommand("text", new DbParameter[0], CommandType.Text) }));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(true, "text", parameters: null),
new[] { new SqlNonQueryCommand("text", new DbParameter[0], CommandType.Text) }));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(true, "text", new { }),
new[] { new SqlNonQueryCommand("text", new DbParameter[0], CommandType.Text) }));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(true, "text", new { Parameter = new TestDbParameter() }),
new[]
{
new SqlNonQueryCommand("text", new[]
{
new TestDbParameter().ToDbParameter("@Parameter")
}, CommandType.Text)
}));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(true, "text",
new { Parameter1 = new TestDbParameter(), Parameter2 = new TestDbParameter() }),
new[]
{
new SqlNonQueryCommand("text", new[]
{
new TestDbParameter().ToDbParameter("@Parameter1"),
new TestDbParameter().ToDbParameter("@Parameter2")
}, CommandType.Text)
}));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(false, "text"),
new SqlNonQueryCommand[0]));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(false, "text", parameters: null),
new SqlNonQueryCommand[0]));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(false, "text", new { }),
new SqlNonQueryCommand[0]));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(false, "text", new { Parameter = new TestDbParameter() }),
new SqlNonQueryCommand[0]));
yield return(new TestCaseData(
TSql.NonQueryStatementIf(false, "text", new { Parameter1 = new TestDbParameter(), Parameter2 = new TestDbParameter() }),
new SqlNonQueryCommand[0]));
}
private static IEnumerable <TestCaseData> QueryProcedureIfCases()
{
yield return(new TestCaseData(
TSql.QueryProcedureIf(true, "text"),
new[] { new SqlQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure) }));
yield return(new TestCaseData(
TSql.QueryProcedureIf(true, "text", parameters: null),
new[] { new SqlQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure) }));
yield return(new TestCaseData(
TSql.QueryProcedureIf(true, "text", new { }),
new[] { new SqlQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure) }));
yield return(new TestCaseData(
TSql.QueryProcedureIf(true, "text", new { Parameter = new TestDbParameter() }),
new[]
{
new SqlQueryCommand("text", new[]
{
new TestDbParameter().ToDbParameter("@Parameter")
}, CommandType.StoredProcedure)
}));
yield return(new TestCaseData(
TSql.QueryProcedureIf(true, "text",
new { Parameter1 = new TestDbParameter(), Parameter2 = new TestDbParameter() }),
new[]
{
new SqlQueryCommand("text", new[]
{
new TestDbParameter().ToDbParameter("@Parameter1"),
new TestDbParameter().ToDbParameter("@Parameter2")
}, CommandType.StoredProcedure)
}));
yield return(new TestCaseData(
TSql.QueryProcedureIf(false, "text"),
new SqlQueryCommand[0]));
yield return(new TestCaseData(
TSql.QueryProcedureIf(false, "text", parameters: null),
new SqlQueryCommand[0]));
yield return(new TestCaseData(
TSql.QueryProcedureIf(false, "text", new { }),
new SqlQueryCommand[0]));
yield return(new TestCaseData(
TSql.QueryProcedureIf(false, "text", new { Parameter = new TestDbParameter() }),
new SqlQueryCommand[0]));
yield return(new TestCaseData(
TSql.QueryProcedureIf(false, "text", new { Parameter1 = new TestDbParameter(), Parameter2 = new TestDbParameter() }),
new SqlQueryCommand[0]));
}
public CustomerProjection()
{
When <CustomerCreated>(@event =>
TSql.NonQueryStatement(
"INSERT INTO [Customer] ([Id], [Name]) VALUES (@P1, @P2)",
new { P1 = TSql.UniqueIdentifier(@event.Id), P2 = TSql.NVarChar(@event.CustomerName, 40) }
));
When <CustomerNameChanged>(@event =>
TSql.NonQueryStatement(
"UPDATE [Customer] SET [Name] = @P2 WHERE [Id] = @P1",
new { P1 = TSql.UniqueIdentifier(@event.Id), P2 = TSql.NVarChar(@event.NewCustomerName, 40) }
));
When <NewUserAdded>(@event =>
TSql.NonQueryStatement(
"INSERT INTO [CustomerUser] ([Id], [CustomerId], [Name]) VALUES (@P1, @P2, @P3)",
new { P1 = TSql.UniqueIdentifier(@event.UserId),
P2 = TSql.UniqueIdentifier(@event.CustomerId),
P3 = TSql.NVarChar(@event.UserName, 40) }
));
When <UserNameChanged>(@event =>
TSql.NonQueryStatement(
"UPDATE [CustomerUser] SET [Name] = @P2 WHERE [Id] = @P1",
new { P1 = TSql.UniqueIdentifier(@event.UserId), P2 = TSql.NVarChar(@event.NewUserName, 40) }
));
When <CreateSchema>(_ =>
TSql.NonQueryStatement(
@"IF NOT EXISTS (SELECT * FROM SYSOBJECTS WHERE NAME='Customer' AND XTYPE='U')
BEGIN
CREATE TABLE [Customer] (
[Id] UNIQUEIDENTIFIER NOT NULL CONSTRAINT PK_Customer PRIMARY KEY,
[Name] NVARCHAR(MAX) NOT NULL)
END
IF NOT EXISTS (SELECT * FROM SYSOBJECTS WHERE NAME='CustomerUser' AND XTYPE='U')
BEGIN
CREATE TABLE [CustomerUser] (
[Id] UNIQUEIDENTIFIER NOT NULL CONSTRAINT PK_CustomerUser PRIMARY KEY,
[CustomerId] UNIQUEIDENTIFIER NOT NULL,
[Name] NVARCHAR(MAX) NOT NULL)
END"));
When <DropSchema>(_ => new[] {
TSql.NonQueryStatement(
@"IF EXISTS (SELECT * FROM SYSOBJECTS WHERE NAME='Customer' AND XTYPE='U')
DROP TABLE [Customer]"),
TSql.NonQueryStatement(
@"IF EXISTS (SELECT * FROM SYSOBJECTS WHERE NAME='CustomerUser' AND XTYPE='U')
DROP TABLE [CustomerUser]")
});
When <DeleteData>(_ => new [] {
TSql.NonQueryStatement(
@"IF EXISTS (SELECT * FROM SYSOBJECTS WHERE NAME='Customer' AND XTYPE='U')
DELETE FROM [Customer]"),
TSql.NonQueryStatement(
@"IF EXISTS (SELECT * FROM SYSOBJECTS WHERE NAME='CustomerUser' AND XTYPE='U')
DELETE FROM [CustomerUser]")
});
}
public void ValidateUserAccount()
{
//Try to run sql procedure to check the user accounts, the procedure changes the state of the user accordingly
try
{
TSql.ExecuteNonQuery("spCheckUserAccountExpiry", this.ConnectionString);
}
catch (Exception ex)
{
EventLogger.LogEvent(EventLogType.Error, ex);
}
}
public void ComposedCommandArrayIsPreservedAndReturnedByComposer()
{
var command1 = CommandFactory();
var command2 = CommandFactory();
SqlNonQueryCommand[] result = TSql.Compose(command1, command2);
Assert.That(result, Is.EquivalentTo(new []
{
command1, command2
}));
}
public void ComposedIfCommandEnumerationIsNotPreservedAndReturnedByComposerWhenConditionIsFalse()
{
var command1 = CommandFactory();
var command2 = CommandFactory();
SqlNonQueryCommand[] result = TSql.ComposeIf(false, (IEnumerable <SqlNonQueryCommand>) new[]
{
command1, command2
});
Assert.That(result, Is.EquivalentTo(new SqlNonQueryCommand[0]));
}
public string GetCheckpoint()
{
const string sql = @"SELECT [CheckpointToken] FROM [StoreCheckpoint] WHERE [StoreId] = @P1";
using (var reader = _executer.ExecuteReader(TSql.QueryStatement(sql, new { P1 = TSql.NVarCharMax(_tenantId) })))
{
if (reader.IsClosed)
{
return(null);
}
return(reader.Read() ? reader.GetString(0) : null);
}
}
static void Main(string[] args)
{
Benchmark.Begin += (name, id) =>
{
using (ConsoleUtil.Color(fg: ConsoleColor.Green))
Console.WriteLine("{0}:{1}->{2}", id, name, DateTime.Now);
};
Benchmark.End += (name, id, elapse) =>
{
using (ConsoleUtil.Color(fg: ConsoleColor.Green))
Console.WriteLine("{0}:{1}->{2}ms, {3}", id, name, elapse, DateTime.Now);
};
using (Benchmark.Start("*"))
{
try
{
List <IStatement> ast;
using (Benchmark.Start("parse"))
ast = TSql.ParseFile("Test.sql").ToList();
using (HashAlgorithm hash = MD5.Create())
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream))
{
using (Benchmark.Start("format"))
{
ast.Write(writer);
writer.Flush();
}
stream.Seek(0, SeekOrigin.Begin);
byte[] hashBytes;
using (Benchmark.Start("hash"))
hashBytes = hash.ComputeHash(stream);
Console.WriteLine("Hash is '{0}'", Format(hashBytes));
}
}
catch (Exception e)
{
using (ConsoleUtil.Color(ConsoleColor.Red))
Console.WriteLine(e.Message);
}
}
Console.WriteLine("Press any key to quit...");
Console.ReadKey(true);
}
public static IEnumerable <object> Project(ItemPurchased purchased, Guid nextEventId, int checkpointPosition)
{
yield return(TSql.NonQueryStatement(@"insert into ItemsPurchased (StockKeepingUnit) values (@StockKeepingUnit)", new
{
StockKeepingUnit = TSql.VarCharMax(purchased.StockKeepingUnit)
}));
yield return(TSql.NonQueryStatement(@"insert into StreamCheckpoint (Position) values (@Position)", new
{
Position = TSql.Int(checkpointPosition)
}));
yield return(new WriteToStream(nextEventId, "egress", new CheckpointEvent(checkpointPosition)));
}
public void ComposedCommandEnumerationIsPreservedAndReturnedByComposer()
{
var command1 = CommandFactory();
var command2 = CommandFactory();
SqlNonQueryCommand[] result = TSql.Compose((IEnumerable <SqlNonQueryCommand>) new[]
{
command1, command2
});
Assert.That(result, Is.EquivalentTo(new[]
{
command1, command2
}));
}
public IEnumerable <string> GetTenantIds()
{
using (var reader = _executer.ExecuteReader(TSql.QueryStatement(@"SELECT [StoreId] FROM [StoreCheckpoint]")))
{
if (reader.IsClosed)
{
yield break;
}
while (reader.Read())
{
yield return(reader.GetString(0));
}
}
}
public PortfolioProjection()
{
When <PortfolioAdded>(@event =>
TSql.NonQueryStatement(
"INSERT INTO [Portfolio] (Id, Name) VALUES (@P1, @P2)",
new { P1 = TSql.Int(@event.Id), P2 = TSql.NVarChar(@event.Name, 40) }
));
When <PortfolioRemoved>(@event =>
TSql.NonQueryStatement(
"DELETE FROM [Portfolio] WHERE Id = @P1",
new { P1 = TSql.Int(@event.Id) }
));
When <PortfolioRenamed>(@event =>
TSql.NonQueryStatement(
"UPDATE [Portfolio] SET Name = @P2 WHERE Id = @P1",
new { P1 = TSql.Int(@event.Id), P2 = TSql.NVarChar(@event.Name, 40) }
));
}
private static IEnumerable <TestCaseData> QueryStatementFormatCases()
{
yield return(new TestCaseData(
TSql.QueryStatementFormat("text"),
new SqlQueryCommand("text", new DbParameter[0], CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatementFormat("text", parameters: null),
new SqlQueryCommand("text", new DbParameter[0], CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatementFormat("text", new IDbParameterValue[0]),
new SqlQueryCommand("text", new DbParameter[0], CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatementFormat("text", new SqlParameterValueStub()),
new SqlQueryCommand("text", new[]
{
new SqlParameterValueStub().ToDbParameter("@P0")
}, CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatementFormat("text {0}", new SqlParameterValueStub()),
new SqlQueryCommand("text @P0", new[]
{
new SqlParameterValueStub().ToDbParameter("@P0")
}, CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatementFormat("text", new SqlParameterValueStub(), new SqlParameterValueStub()),
new SqlQueryCommand("text", new[]
{
new SqlParameterValueStub().ToDbParameter("@P0"),
new SqlParameterValueStub().ToDbParameter("@P1")
}, CommandType.Text)));
yield return(new TestCaseData(
TSql.QueryStatementFormat("text {0} {1}", new SqlParameterValueStub(), new SqlParameterValueStub()),
new SqlQueryCommand("text @P0 @P1", new[]
{
new SqlParameterValueStub().ToDbParameter("@P0"),
new SqlParameterValueStub().ToDbParameter("@P1")
}, CommandType.Text)));
}
private static IEnumerable <TestCaseData> NonQueryProcedureFormatCases()
{
yield return(new TestCaseData(
TSql.NonQueryProcedureFormat("text"),
new SqlNonQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedureFormat("text", parameters: null),
new SqlNonQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedureFormat("text", new IDbParameterValue[0]),
new SqlNonQueryCommand("text", new DbParameter[0], CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedureFormat("text", new SqlParameterValueStub()),
new SqlNonQueryCommand("text", new[]
{
new SqlParameterValueStub().ToDbParameter("@P0")
}, CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedureFormat("text {0}", new SqlParameterValueStub()),
new SqlNonQueryCommand("text @P0", new[]
{
new SqlParameterValueStub().ToDbParameter("@P0")
}, CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedureFormat("text", new SqlParameterValueStub(), new SqlParameterValueStub()),
new SqlNonQueryCommand("text", new[]
{
new SqlParameterValueStub().ToDbParameter("@P0"),
new SqlParameterValueStub().ToDbParameter("@P1")
}, CommandType.StoredProcedure)));
yield return(new TestCaseData(
TSql.NonQueryProcedureFormat("text {0} {1}", new SqlParameterValueStub(), new SqlParameterValueStub()),
new SqlNonQueryCommand("text @P0 @P1", new[]
{
new SqlParameterValueStub().ToDbParameter("@P0"),
new SqlParameterValueStub().ToDbParameter("@P1")
}, CommandType.StoredProcedure)));
}
static void Main(string[] args)
{
Benchmark.Begin += (name, id) =>
{
using (ConsoleUtil.Color(fg: ConsoleColor.Green))
Console.WriteLine("{0}:{1}->{2}", id, name, DateTime.Now);
};
Benchmark.End += (name, id, elapse) =>
{
using (ConsoleUtil.Color(fg: ConsoleColor.Green))
Console.WriteLine("{0}:{1}->{2}ms, {3}", id, name, elapse, DateTime.Now);
};
using (Benchmark.Start("*"))
{
try
{
List <IStatement> ast;
using (Benchmark.Start("parse"))
ast = TSql.ParseFile("Test.sql").ToList();
string json;
using (Benchmark.Start("serialize"))
json = (JsonConvert.SerializeObject(ast, Formatting.Indented,
new JsonConverter[] { new StringEnumConverter() }));
using (Benchmark.Start("write"))
File.WriteAllText("ast.out.json", json);
}
catch (Exception e)
{
using (ConsoleUtil.Color(ConsoleColor.Red))
Console.WriteLine(e.Message);
}
}
Console.WriteLine("Press any key to quit...");
Console.ReadKey(true);
}
public DataSet Open(TSql Sql, string[] param)
{
return dbProvider.Open(string.Format(ASql[(int)Sql], param));
}
public void ComposeUnlessCommandEnumerationCanBeNullWhenConditionIsTrue()
{
Assert.DoesNotThrow(() => TSql.ComposeUnless(true, (IEnumerable <SqlNonQueryCommand>)null));
}
public void ComposeUnlessCommandEnumerationCanNotBeNullWhenConditionIsFalse()
{
Assert.Throws <ArgumentNullException>(() => TSql.ComposeUnless(false, (IEnumerable <SqlNonQueryCommand>)null));
}
public void ComposeIfCommandEnumerationCanBeNullWhenConditionIsFalse()
{
Assert.DoesNotThrow(() => TSql.ComposeIf(false, (IEnumerable <SqlNonQueryCommand>)null));
}
public void ComposeIfCommandEnumerationCanNotBeNullWhenConditionIsTrue()
{
Assert.Throws <ArgumentNullException>(() => TSql.ComposeIf(true, (IEnumerable <SqlNonQueryCommand>)null));
}
public void ComposeCommandEnumerationCanNotBeNull()
{
Assert.Throws <ArgumentNullException>(() => TSql.Compose((IEnumerable <SqlNonQueryCommand>)null));
}
public DataTable OpenTable(TSql Sql, string[] param)
{
return dbProvider.OpenTable(string.Format(ASql[(int)Sql], param));
}
