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)); }