Datei: NDODLL.Tests/QueryTests/QueryTests.cs

Last Commit (e0dce83)

1	using System;
2	using System.Collections.Generic;
3	using NUnit.Framework;
4	using NDO;
5	using NDO.Application;
6	using NDO.Query;
7	using NDOql.Expressions;
8	using Reisekosten;
9	using Reisekosten.Personal;
10	using PureBusinessClasses;
11	using NDO.SqlPersistenceHandling;
12	using Moq;
13	using System.Collections;
14	using System.Data;
15	using DataTypeTestClasses;
16	using Microsoft.Extensions.DependencyInjection;
17	using Microsoft.Extensions.Hosting;
18	using Microsoft.Extensions.Logging;
19
20	namespace QueryTests
21	{
22	····[TestFixture]
23	····public class NDOQueryTests
24	····{
25	········PersistenceManager pm;
26	········string mitarbeiterFields;
27	········string mitarbeiterJoinFields;
28	········string belegFields;
29	········string pkwFahrtFields;
30	········string reiseJoinFields;
31	········// Keep this variable, because it holds the serviceProvider during the test;
32	········IServiceProvider serviceProvider;
33
34
35	········[SetUp]
36	········public void SetUp()
37	········{
38	········}
39
40
41	········void Build( Action<IServiceCollection> configure = null )
42	········{
43	············var builder = Host.CreateDefaultBuilder();
44	············builder.ConfigureServices( services =>
45	············{
46	················services.AddLogging( b =>
47	················{
48	····················b.ClearProviders();
49	····················b.AddConsole();
50	················} );
51
52	················services.AddNdo( null, null );
53	················if (configure != null)
54	····················configure( services );
55	············} );
56
57	············var host = builder.Build();
58	············this.serviceProvider = host.Services;
59	············host.Services.UseNdo();
60
61	············this.pm = NDOFactory.Instance.PersistenceManager;
62
63	············mitarbeiterFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ) ).SelectList;
64	············mitarbeiterJoinFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ) ).Result( false, false, true );
65	············belegFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Beleg ) ) ).SelectList;
66	············this.pkwFahrtFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( PKWFahrt ) ) ).SelectList;
67	············this.reiseJoinFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Reise ) ) ).Result( false, false, true );
68	········}
69
70
71	········[TearDown]
72	········public void TearDown()
73	········{
74	var pm = NDOFactory. Instance. PersistenceManager;
75	pm. Delete( pm. Objects<Mitarbeiter>( ) . ResultTable ) ;
76	pm. Save( ) ;
77	········}
78
79
80	········[Test]
81	········public void QueryWithEmptyGuidParameterSearchesForNull()
82	········{
83	············Build();
84	············// The query will fetch for DataContainerDerived objects, too.
85	············// Hence we test with "StartsWith", because the query contains additional text, which doesn't matter here.
86	············var q = new NDOQuery<DataContainer>(pm, "guidVar = {0}");
87	············q.Parameters.Add( Guid.Empty );
88	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( DataContainer ) ) ).SelectList;
89	············var sql = $"SELECT {fields} FROM [DataContainer] WHERE [DataContainer].[GuidVar] IS NULL";
90	············Assert.That( q.GeneratedQuery.StartsWith( sql ) );
91
92	············q = new NDOQuery<DataContainer>(pm, "guidVar <> {0}");
93	············q.Parameters.Add( Guid.Empty );
94	············sql = $"SELECT {fields} FROM [DataContainer] WHERE [DataContainer].[GuidVar] IS NOT NULL";
95	············Assert.That( q.GeneratedQuery.StartsWith( sql ) );
96	········}
97
98	········[Test]
99	········public void QueryWithDateTimeMinValueParameterSearchesForNull()
100	········{
101	············Build();
102	············// The query will fetch for DataContainerDerived objects, too.
103	············// Hence we test with "StartsWith", because the query contains additional text, which doesn't matter here.
104	············var q = new NDOQuery<DataContainer>(pm, "dateTimeVar = {0}");
105	············q.Parameters.Add( DateTime.MinValue );
106	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( DataContainer ) ) ).SelectList;
107	············var sql = $"SELECT {fields} FROM [DataContainer] WHERE [DataContainer].[DateTimeVar] IS NULL";
108	············Assert.That( q.GeneratedQuery.StartsWith( sql ) );
109
110	············q = new NDOQuery<DataContainer>(pm, "dateTimeVar <> {0}");
111	············q.Parameters.Add( DateTime.MinValue );
112	············sql = $"SELECT {fields} FROM [DataContainer] WHERE [DataContainer].[DateTimeVar] IS NOT NULL";
113	············Assert.That( q.GeneratedQuery.StartsWith( sql ) );
114
115	········}
116
117	········[Test]
118	········public void CheckIfQueryWithoutWhereClauseWorks()
119	········{
120	············Build();
121	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
122	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter]", this.mitarbeiterFields ) == q.GeneratedQuery );
123	········}
124
125	········[Test]
126	········public void CheckIfSimplePrefetchWorks()
127	········{
128	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
129	············q.AddPrefetch( "dieReisen" );
130	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter]", this.mitarbeiterFields ) == q.GeneratedQuery );
131	········}
132
133	········public void CheckMitarbeiterQuery()
134	········{
135	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
136	············List<Mitarbeiter> l = q.Execute();
137	············Assert.That( 2 == l.Count );
138	········}
139
140	········[Test]
141	········public void CheckIfSimpleWhereClauseWorks()
142	········{
143	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = 'Mirko'" );
144	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'Mirko'", this.mitarbeiterFields ) == q.GeneratedQuery );
145	············q = new NDOQuery<Mitarbeiter>( pm, "vorname LIKE 'M*'" );
146	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] LIKE 'M*'", this.mitarbeiterFields ) == q.GeneratedQuery );
147	············q = new NDOQuery<Mitarbeiter>( pm, "oid = 1" );
148	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[ID] = 1", this.mitarbeiterFields ) == q.GeneratedQuery );
149	············q = new NDOQuery<Mitarbeiter>( pm, "oid(0) = 1" );
150	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[ID] = 1", this.mitarbeiterFields ) == q.GeneratedQuery );
151	········}
152
153	········[Test]
154	········public void CheckIfFunctionsWork()
155	········{
156	············Build();
157	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = SqlFunction('Mirko')" );
158	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = SqlFunction('Mirko')", this.mitarbeiterFields ) == q.GeneratedQuery );
159	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = SqlFunction('Mirko', 42)" );
160	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = SqlFunction('Mirko', 42)", this.mitarbeiterFields ) == q.GeneratedQuery );
161	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = SqlFunction()" );
162	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = SqlFunction()", this.mitarbeiterFields ) == q.GeneratedQuery );
163	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = SqlFunction(nachname)" );
164	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = SqlFunction([Mitarbeiter].[Nachname])", this.mitarbeiterFields ) == q.GeneratedQuery );
165	············q = new NDOQuery<Mitarbeiter>( pm, "SqlFunction('Mirko', 42) > 3124" );
166	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE SqlFunction('Mirko', 42) > 3124", this.mitarbeiterFields ) == q.GeneratedQuery );
167	········}
168
169	········[Test]
170	········public void CheckIfGeneratedQueryCanBeCalledTwice()
171	········{
172	············Build();
173	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = 'Mirko'" );
174	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'Mirko'", this.mitarbeiterFields ) == q.GeneratedQuery );
175	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'Mirko'", this.mitarbeiterFields ) == q.GeneratedQuery );
176	········}
177
178	········[Test]
179	········[TestCase( true )]
180	········[TestCase( false )]
181	········public void SkipTakeParametersDontChangeTheCoreQuery(bool asc)
182	········{
183	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
184	············q.Parameters.Add( "Mirko" );
185	············if (asc)
186	················q.Orderings.Add( new AscendingOrder( "vorname" ) );
187	············else
188	················q.Orderings.Add( new DescendingOrder( "vorname" ) );
189	············q.Take = 10;
190	············var desc = asc ? "" : "DESC ";
191	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] {desc}OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
192	············q.Skip = 10;
193	············q.Take = 10;
194	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] {desc}OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
195	········}
196
197	········[Test]
198	········public void MixedOrderingsWork()
199	········{
200	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
201	············q.Parameters.Add( "Mirko" );
202	············q.Orderings.Add( new AscendingOrder( "vorname" ) );
203	············q.Orderings.Add( new DescendingOrder( "nachname" ) );
204	············q.Take = 10;
205	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] ASC, [Mitarbeiter].[Nachname] DESC OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
206	············q.Skip = 10;
207	············q.Take = 10;
208	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] ASC, [Mitarbeiter].[Nachname] DESC OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
209	········}
210
211	········[Test]
212	········public void OrderingByOidWorks()
213	········{
214	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
215	············q.Parameters.Add( "Mirko" );
216	············q.Orderings.Add( new AscendingOrder( "oid" ) );
217	············q.Take = 10;
218	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[ID] OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
219	············q.Skip = 10;
220	············q.Take = 10;
221	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[ID] OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
222
223	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
224	············q.Parameters.Add( "Mirko" );
225	············q.Orderings.Add( new DescendingOrder( "oid" ) );
226	············q.Take = 10;
227	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[ID] DESC OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
228	············q.Skip = 10;
229	············q.Take = 10;
230	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[ID] DESC OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
231	········}
232
233	········[Test]
234	········[TestCase( true )]
235	········[TestCase( false )]
236	········public void ParametersChangesDontChangeTheCoreQuery(bool asc)
237	········{
238	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
239	············if (asc)
240	················q.Orderings.Add( new AscendingOrder( "vorname" ) );
241	············else
242	················q.Orderings.Add( new DescendingOrder( "vorname" ) );
243	············q.Take = 10;
244	············q.Parameters.Add( "Mirko" );
245	············var desc = asc ? "" : "DESC ";
246	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] {desc}OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
247	············q.Parameters.Add( "Hans" );
248	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] {desc}OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
249	········}
250
251	········[Test]
252	········public void CheckIfWhereClauseWith1nRelationWorks()
253	········{
254	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.zweck = 'ADC'" );
255	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[Zweck] = 'ADC'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
256	············q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.oid = {0}" );
257	············q.Parameters.Add( 1 );
258	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[ID] = {{0}}", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
259	········}
260
261	········[Test]
262	········public void CheckIfWhereClauseWith11RelationWorks()
263	········{
264	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse.lkz LIKE 'D%'" );
265	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Adresse] ON [Adresse].[ID] = [Mitarbeiter].[IDAdresse] WHERE [Adresse].[Lkz] LIKE 'D%'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
266	········}
267
268	········[Test]
269	········public void CheckIfMultipleRelationsWork()
270	········{
271	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse.lkz LIKE 'D%' AND dieReisen.dieLaender.name = 'D'" );
272	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Adresse] ON [Adresse].[ID] = [Mitarbeiter].[IDAdresse] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] INNER JOIN [relLandReise] ON [Reise].[ID] = [relLandReise].[IDReise] INNER JOIN [Land] ON [Land].[ID] = [relLandReise].[IDLand] WHERE [Adresse].[Lkz] LIKE 'D%' AND [Land].[Name] = 'D'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
273	········}
274
275	········[Test]
276	········public void CheckOidWithTable()
277	········{
278	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.dieLaender.oid = {0}" );
279	············q.Parameters.Add( 1 );
280	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] INNER JOIN [relLandReise] ON [Reise].[ID] = [relLandReise].[IDReise] WHERE [relLandReise].[IDLand] = {{0}}", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
281	········}
282
283	········[Test]
284	········public void CheckThatOneJoinAppearsOnlyOneTime()
285	········{
286	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse.lkz LIKE 'D%' AND adresse.ort <> 'Bad Tölz'" );
287	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Adresse] ON [Adresse].[ID] = [Mitarbeiter].[IDAdresse] WHERE [Adresse].[Lkz] LIKE 'D%' AND [Adresse].[Ort] <> 'Bad Tölz'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
288	············q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.zweck = 'ADC' OR dieReisen.zweck = 'ADW'" );
289	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[Zweck] = 'ADC' OR [Reise].[Zweck] = 'ADW'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
290	········}
291
292	········[Test]
293	········public void CheckNotOperator()
294	········{
295	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "NOT (vorname LIKE 'M%')" );
296	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE NOT ([Mitarbeiter].[Vorname] LIKE 'M%')", this.mitarbeiterFields ) == q.GeneratedQuery );
297	············q = new NDOQuery<Mitarbeiter>( pm, "vorname LIKE 'M%' AND NOT nachname = 'Matytschak'" );
298	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] LIKE 'M%' AND NOT [Mitarbeiter].[Nachname] = 'Matytschak'", this.mitarbeiterFields ) == q.GeneratedQuery );
299	············q = new NDOQuery<Mitarbeiter>( pm, "NOT (vorname LIKE 'M%' AND nachname = 'Matytschak')" );
300	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE NOT ([Mitarbeiter].[Vorname] LIKE 'M%' AND [Mitarbeiter].[Nachname] = 'Matytschak')", this.mitarbeiterFields ) == q.GeneratedQuery );
301	············q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.zweck = 'ADC' OR NOT dieReisen.zweck = 'ADW'" );
302	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[Zweck] = 'ADC' OR NOT [Reise].[Zweck] = 'ADW'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
303	············q = new NDOQuery<Mitarbeiter>( pm, "NOT (dieReisen.zweck = 'ADC' OR dieReisen.zweck = 'ADW')" );
304	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE NOT ([Reise].[Zweck] = 'ADC' OR [Reise].[Zweck] = 'ADW')", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
305	············bool thrown = false;
306	············try
307	············{
308	················q = new NDOQuery<Mitarbeiter>( pm, "vorname LIKE 'M%' AND nachname = NOT 'Matytschak'" );
309	················string s = q.GeneratedQuery;
310	············}
311	············catch (OqlExpressionException)
312	············{
313	················thrown = true;
314	············}
315	············Assert.That( thrown );
316
317	············// TODO: This is a wrong expression which passes the syntax check.
318	············// Mysql allows WHERE NOT True but disallows nachname = NOT True
319	············// Sql Server doesn't know the symbol True
320	············q = new NDOQuery<Mitarbeiter>( pm, "vorname LIKE 'M%' AND nachname = NOT True" );
321	············string t = q.GeneratedQuery; // Make sure, GeneratedQuery ist called twice.
322	············Console.WriteLine(t);
323	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] LIKE 'M%' AND [Mitarbeiter].[Nachname] = NOT TRUE" == q.GeneratedQuery );
324	········}
325
326	········[Test]
327	········public void CheckBetween()
328	········{
329	············Build();
330	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname BETWEEN 'A' AND 'B'" );
331	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] BETWEEN 'A' AND 'B'" == q.GeneratedQuery );
332	············q = new NDOQuery<Mitarbeiter>( pm, "NOT vorname BETWEEN 'A' AND 'B'" );
333	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE NOT [Mitarbeiter].[Vorname] BETWEEN 'A' AND 'B'" == q.GeneratedQuery );
334	············q = new NDOQuery<Mitarbeiter>( pm, "NOT (vorname BETWEEN 'A' AND 'B')" );
335	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE NOT ([Mitarbeiter].[Vorname] BETWEEN 'A' AND 'B')" == q.GeneratedQuery );
336	········}
337
338	········[Test]
339	········public void TestValueType()
340	········{
341	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "position.X > 2 AND position.Y < 5" );
342	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Position_X] > 2 AND [Mitarbeiter].[Position_Y] < 5" == q.GeneratedQuery );
343	········}
344
345	········[Test]
346	········public void TestValueTypeRelation()
347	········{
348	············NDOQuery<Sozialversicherungsnummer> q = new NDOQuery<Sozialversicherungsnummer>( pm, "arbeiter.position.X > 2 AND arbeiter.position.Y < 5" );
349	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Sozialversicherungsnummer ) ) ).Result( false, false, true );
350	············Assert.That( String.Format( $"SELECT {fields} FROM [Sozialversicherungsnummer] INNER JOIN [Mitarbeiter] ON [Mitarbeiter].[ID] = [Sozialversicherungsnummer].[IDSozial] WHERE [Mitarbeiter].[Position_X] > 2 AND [Mitarbeiter].[Position_Y] < 5", this.mitarbeiterFields ) == q.GeneratedQuery );
351	········}
352
353	········[Test]
354	········public void CheckFetchGroupInitializationWithExpressions()
355	········{
356	············Build();
357	············FetchGroup<Mitarbeiter> fg = new FetchGroup<Mitarbeiter>( m => m.Vorname, m => m.Nachname );
358	············Assert.That( fg.Count == 2, "Count should be 2" );
359	············Assert.That( "Vorname" == fg[0], "Name wrong #1" );
360	············Assert.That( "Nachname" == fg[1], "Name wrong #2" );
361	········}
362
363	········[Test]
364	········public void CheckIfSyntaxErrorThrowsAQueryException()
365	········{
366	············bool qeThrown = false;
367	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname IN 'Mirko'" );
368	············try
369	············{
370	················var s = q.GeneratedQuery;
371	············}
372	············catch (OqlExpressionException)
373	············{
374	················qeThrown = true;
375	············}
376
377	············Assert.That( qeThrown, "Syntax Error should throw an OqlExpressionException" );
378	········}
379
380	········[Test]
381	········public void CheckIfMultiKeysWork()
382	········{
383	············NDOQuery<OrderDetail> q = new NDOQuery<OrderDetail>( pm, "oid = {0}" );
384	············var od = pm.FindObject(typeof(OrderDetail), new object[]{ 1, 2 } );
385	············q.Parameters.Add( od.NDOObjectId );
386	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( OrderDetail ) ) ).SelectList;
387	············Assert.That( $"SELECT {fields} FROM [OrderDetail] WHERE [OrderDetail].[IDProduct] = {{0}} AND [OrderDetail].[IDOrder] = {{1}}" == q.GeneratedQuery );
388	············bool thrown = false;
389	············try
390	············{
391	················q = new NDOQuery<OrderDetail>( pm, "oid = -4" );
392	················string s = q.GeneratedQuery;
393	············}
394	············catch (NDOException)
395	············{
396	················thrown = true;
397	············}
398	············Assert.That( thrown );
399	········}
400
401	········[Test]
402	········public void CheckIfMultiKeyObjectIdParametersAreProcessed()
403	········{
404	············IList generatedParameters = null;
405	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
406	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
407
408	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
409
410	············NDOQuery<OrderDetail> q = new NDOQuery<OrderDetail>( pm, "oid = {0}" );
411	············ObjectId oid = pm.FindObject( typeof( OrderDetail ), new object[] { 1, 2 } ).NDOObjectId;
412	············q.Parameters.Add( oid );
413
414	············q.Execute();
415
416	············Assert.That( generatedParameters != null );
417	············Assert.That( 2 == generatedParameters.Count );
418	············Assert.That( 1 == (int) generatedParameters[0] );
419	············Assert.That( 2 == (int) generatedParameters[1] );
420	········}
421
422	········[Test]
423	········public void CheckIfMultiKeyArrayParametersAreProcessed()
424	········{
425	············IList generatedParameters = null;
426	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
427	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
428	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
429
430	············NDOQuery<OrderDetail> q = new NDOQuery<OrderDetail>( pm, "oid = {0}" );
431	············q.Parameters.Add( new object[] { 1, 2 } );
432	············q.Execute();
433	············Assert.That( generatedParameters != null );
434	············Assert.That( 2 == generatedParameters.Count );
435	············Assert.That( 1 == (int) generatedParameters[0] );
436	············Assert.That( 2 == (int) generatedParameters[1] );
437	········}
438
439
440	········[Test]
441	········public void CheckIfSingleKeyOidParameterIsProcessed()
442	········{
443	············IList generatedParameters = null;
444	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
445	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
446	············var handler = handlerMock.Object;
447	············Mock<IPersistenceHandlerManager> phManagerMock = new Mock<IPersistenceHandlerManager>();
448	············phManagerMock.Setup( m => m.GetPersistenceHandler( It.IsAny<Type>() ) ).Returns( handler ).Callback<Type>( ( pc ) => { Console.WriteLine("Test"); });
449	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
450
451	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "oid = {0}" );
452	············q.Parameters.Add( 1 );
453	············q.Execute();
454	············Assert.That( generatedParameters··!= null );
455	············Assert.That( 1 == generatedParameters.Count );
456	············Assert.That( 1 == (int) generatedParameters[0] );
457	········}
458
459	········[Test]
460	········public void CheckIfSqlQueryIsProcessed()
461	········{
462	············IList generatedParameters = null;
463	············string expression = null;
464	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
465	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => { generatedParameters = l; expression = s; } );
466	············var handler = handlerMock.Object;
467	············Mock<IPersistenceHandlerManager> phManagerMock = new Mock<IPersistenceHandlerManager>();
468	············phManagerMock.Setup( m => m.GetPersistenceHandler( It.IsAny<Type>() ) ).Returns( handler );
469	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
470
471	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "SELECT * FROM Mitarbeiter WHERE ID = {0}", false, QueryLanguage.Sql );
472	············q.Parameters.Add( 1 );
473	············q.Execute();
474	············Assert.That( generatedParameters··!= null );
475	············Assert.That( 1 == generatedParameters.Count );
476	············Assert.That( 1 == (int) generatedParameters[0] );
477	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM Mitarbeiter WHERE ID = {{0}}" == expression );
478	········}
479
480	········[Test]
481	········public void CheckIfSingleKeyNDOObjectIdParameterIsProcessed()
482	········{
483	············IList generatedParameters = null;
484	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
485	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
486	············var handler = handlerMock.Object;
487	············Mock<IPersistenceHandlerManager> phManagerMock = new Mock<IPersistenceHandlerManager>();
488	············phManagerMock.Setup( m => m.GetPersistenceHandler( It.IsAny<Type>() ) ).Returns( handler ).Callback<Type>( ( pc ) => { Console.WriteLine( "Test" ); } );
489	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
490
491
492	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "oid = {0}" );
493	············var dummy = (IPersistenceCapable) pm.FindObject( typeof( Mitarbeiter ), 121 );
494	············q.Parameters.Add( dummy.NDOObjectId );
495	············q.Execute();
496	············Assert.That( generatedParameters··!= null );
497	············Assert.That( 1 == generatedParameters.Count );
498	············Assert.That( 121 == (int) generatedParameters[0] );
499	········}
500
501	········[Test]
502	········public void SimpleQueryWithHandler()
503	········{
504	············IList generatedParameters = null;
505	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
506	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
507	············var handler = handlerMock.Object;
508	············Mock<IPersistenceHandlerManager> phManagerMock = new Mock<IPersistenceHandlerManager>();
509	············phManagerMock.Setup( m => m.GetPersistenceHandler( It.IsAny<Type>() ) ).Returns( handler ).Callback<Type>( ( pc ) => { Console.WriteLine( "Test" ); } );
510	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
511
512	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
513	············q.Execute();
514	············Assert.That( generatedParameters··!= null );
515	············Assert.That( 0 == generatedParameters.Count );
516	········}
517
518	········[Test]
519	········public void TestSuperclasses()
520	········{
521	············NDOQuery<Kostenpunkt> qk = new NDOQuery<Kostenpunkt>( pm );
522	············Assert.That( $"SELECT {this.belegFields} FROM [Beleg];\r\nSELECT {this.pkwFahrtFields} FROM [PKWFahrt]" == qk.GeneratedQuery );
523	········}
524
525	········[Test]
526	········public void TestPolymorphicRelationQueries()
527	········{
528	············NDOQuery<Reise> q = new NDOQuery<Reise>( pm, "belege.datum = {0}" );
529	············q.Parameters.Add( DateTime.Now );
530	············Assert.That( $"SELECT {reiseJoinFields} FROM [Reise] INNER JOIN [relBelegKostenpunkt] ON [Reise].[ID] = [relBelegKostenpunkt].[IDReise] INNER JOIN [Beleg] ON [Beleg].[ID] = [relBelegKostenpunkt].[IDBeleg] AND [relBelegKostenpunkt].[TCBeleg] = 926149172 WHERE [Beleg].[Datum] = {{0}} UNION \r\nSELECT {reiseJoinFields} FROM [Reise] INNER JOIN [relBelegKostenpunkt] ON [Reise].[ID] = [relBelegKostenpunkt].[IDReise] INNER JOIN [PKWFahrt] ON [PKWFahrt].[ID] = [relBelegKostenpunkt].[IDBeleg] AND [relBelegKostenpunkt].[TCBeleg] = 734406058 WHERE [PKWFahrt].[Datum] = {{0}}" == q.GeneratedQuery );
531	········}
532
533	········[Test]
534	········public void Test1To1()
535	········{
536	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "meinBuero.zimmer = 'abc'" );
537	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Buero] ON [Buero].[ID] = [Mitarbeiter].[IDBuero] WHERE [Buero].[Zimmer] = 'abc'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
538	········}
539
540
541	········[Test]
542	········public void Test1To1Bidirectional()
543	········{
544	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "sn.nummer = 4711" );
545	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Sozialversicherungsnummer] ON [Sozialversicherungsnummer].[ID] = [Mitarbeiter].[IDSozial] WHERE [Sozialversicherungsnummer].[Nummer] = 4711", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
546	············NDOQuery<Sozialversicherungsnummer> qs = new NDOQuery<Sozialversicherungsnummer>( pm, "arbeiter.vorname = 'Mirko'" );
547	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Sozialversicherungsnummer ) ) ).Result( false, false, true );
548	············Assert.That( $"SELECT {fields} FROM [Sozialversicherungsnummer] INNER JOIN [Mitarbeiter] ON [Mitarbeiter].[ID] = [Sozialversicherungsnummer].[IDSozial] WHERE [Mitarbeiter].[Vorname] = 'Mirko'" == qs.GeneratedQuery );
549	········}
550
551	········[Test]
552	········public void Test1To1BiWithTable()
553	········{
554	············NDOQuery<Zertifikat> qz = new NDOQuery<Zertifikat>( pm, "sgn.signature = 'abc'" );
555	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Zertifikat ) ) ).Result( false, false, true );
556	············Assert.That( $"SELECT {fields} FROM [Zertifikat] INNER JOIN [relSignaturZertifikat] ON [Zertifikat].[ID] = [relSignaturZertifikat].[IDZertifikat] INNER JOIN [Signatur] ON [Signatur].[ID] = [relSignaturZertifikat].[IDSignatur] WHERE [Signatur].[Signature] = 'abc'" == qz.GeneratedQuery );
557	············NDOQuery<Signatur> qs = new NDOQuery<Signatur>( pm, "owner.schlüssel = -4" );
558	············string s = qs.GeneratedQuery;
559	············fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Signatur ) ) ).Result( false, false, true );
560	············Assert.That( $"SELECT {fields} FROM [Signatur] INNER JOIN [relSignaturZertifikat] ON [Signatur].[ID] = [relSignaturZertifikat].[IDSignatur] INNER JOIN [Zertifikat] ON [Zertifikat].[ID] = [relSignaturZertifikat].[IDZertifikat] WHERE [Zertifikat].[Schlüssel] = -4" == qs.GeneratedQuery );
561	········}
562
563	········[Test]
564	········public void Test1ToNWithTable()
565	········{
566	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "reiseBüros.name = 'abc'" );
567	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [relMitarbeiterReisebuero] ON [Mitarbeiter].[ID] = [relMitarbeiterReisebuero].[IDMitarbeiter] INNER JOIN [Reisebuero] ON [Reisebuero].[ID] = [relMitarbeiterReisebuero].[IDReisebuero] WHERE [Reisebuero].[Name] = 'abc'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
568	········}
569
570	········[Test]
571	········public void TestIfQueryForNonNullOidsWorks()
572	········{
573	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.dieLaender.oid IS NOT NULL" );
574	············Assert.That( $"SELECT {this.mitarbeiterJoinFields} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] INNER JOIN [relLandReise] ON [Reise].[ID] = [relLandReise].[IDReise] WHERE [relLandReise].[IDLand] IS NOT NULL" == q.GeneratedQuery );
575	········}
576
577	········[Test]
578	········public void TestIfQueryWithNonNullRelationWorks()
579	········{
580	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse IS NOT NULL" );
581	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[IDAdresse] IS NOT NULL" == q.GeneratedQuery );
582	········}
583
584	········[Test]
585	········public void TestIfQueryWithNullRelationWorks()
586	········{
587	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse IS NULL" );
588	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[IDAdresse] IS NULL" == q.GeneratedQuery );
589	········}
590
591	········[Test]
592	········public void TestIfInClauseWorks()
593	········{
594	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname IN (1,2,3,4,5)" );
595	············var s = q.GeneratedQuery;
596	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] IN (1, 2, 3, 4, 5)" == s );
597	········}
598
599	········[Test]
600	········public void TestIfInClauseWithStringsWorks()
601	········{
602	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname IN ('1','2','3','4','5')" );
603	············var s = q.GeneratedQuery;
604	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] IN ('1', '2', '3', '4', '5')" == s );
605	········}
606
607	········[Test]
608	········public void TestIfSingleQuotesAreForbidden()
609	········{
610	············// -- will be interpreted as NDOql comment
611	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = 'lala'--SELECT * FROM Mitarbeiter'" );
612	············var s = q.GeneratedQuery;
613	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'lala'" == s );
614
615	············// -SELECT * FROM is a valid expression, it would result in a sql error
616	············// Mitarbeiter is a syntax error, so the expression is recognized as incorrect from the 33rd character onwards
617	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = 'lala' -SELECT * FROM Mitarbeiter'" );
618	············try
619	············{
620	················s = q.GeneratedQuery;
621	············}
622	············catch (OqlExpressionException)
623	············{
624	················// Expected outcome
625	············}
626	········}
627
628	········[Test]
629	········public void TestIfInClauseWithQuotesInStringsWorks()
630	········{
631	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname IN ('1''','2''3','''3','4','5')" );
632	············var s = q.GeneratedQuery;
633	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] IN ('1''', '2''3', '''3', '4', '5')" == s );
634	········}
635
636	········[Test]
637	········public void TestIfRelationInInClauseWorks()
638	········{
639	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.oid IN (1,2,3,4,5)" );
640	············var s = q.GeneratedQuery;
641	············Assert.That( $"SELECT {this.mitarbeiterJoinFields} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[ID] IN (1, 2, 3, 4, 5)" == s );
642	········}
643
644	········[Test]
645	········public void TestIfOidWithInClauseWorks()
646	········{
647	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "oid IN (1,2,3,4,5)" );
648	············var s = q.GeneratedQuery;
649	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[ID] IN (1, 2, 3, 4, 5)" == s );
650	········}
651
652	········[Test]
653	········public void TestIfSqlCodeWorks()
654	········{
655	············var expression = "SELECT * FROM Mitarbeiter WHERE Vorname = 'Mirko'";
656	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( this.pm, expression, false, QueryLanguage.Sql );
657	············Assert.That( expression == q.GeneratedQuery );
658	········}
659
660	········[Test]
661	········public void GreaterEqualsWorks()
662	········{
663	············var query = new NDOQuery<Mitarbeiter>( NDOFactory.Instance.PersistenceManager, "vorname >= {0} AND vorname < {1}" );
664	············query.Parameters.Add( "ab" );
665	············query.Parameters.Add( "abc" );
666	············query.Orderings.Add( new NDO.Query.DescendingOrder( "vorname" ) );
667	············Assert.That(query.GeneratedQuery.IndexOf( "[Mitarbeiter].[Vorname] >= {0}" ) > -1);
668	············Assert.That( query.GeneratedQuery.IndexOf( "[Mitarbeiter].[Vorname] < {1}" ) > -1 );
669	········}
670
671	········[Test]
672	········public void BitwiseOperatorsWork()
673	········{
674	············Build();
675	············var pm = NDOFactory.Instance.PersistenceManager;
676	············var query = new NDOQuery<Buero>( pm, "Nummer & 2 = 0" );
677	············Assert.That( query.GeneratedQuery.IndexOf( "[Buero].[Nummer] & 2 = 0" ) > -1 );
678	············query = new NDOQuery<Buero>( pm, "Nummer \| 2 = 0" );
679	············Assert.That( query.GeneratedQuery.IndexOf( "[Buero].[Nummer] \| 2 = 0" ) > -1 );
680	········}
681
682	········[Test]
683	········public void DirectDeleteQueryIsCorrect()
684	········{
685	············var q = new NDOQuery<Mitarbeiter>( NDOFactory.Instance.PersistenceManager, "vorname = 'Mirko'" );
686	············var sql = q.GetDirectDeleteQuery();
687	············Assert.That( "DELETE FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'Mirko'" == sql );
688	········}
689
690	········[Test]
691	········public void TransientDelete()
692	········{
693	············var pm = NDOFactory.Instance.PersistenceManager;
694	············var m = new Mitarbeiter();
695	············try
696	············{
697	················pm.Delete( m );
698	············}
699	············catch (NDOException ex)
700	············{
701	················Assert.That( 120 == ex.ErrorNumber );
702	············}
703	········}
704	····}
705	}
706

New Commit (92dda21)

1	using System;
2	using System.Collections.Generic;
3	using NUnit.Framework;
4	using NDO;
5	using NDO.Application;
6	using NDO.Query;
7	using NDOql.Expressions;
8	using Reisekosten;
9	using Reisekosten.Personal;
10	using PureBusinessClasses;
11	using NDO.SqlPersistenceHandling;
12	using Moq;
13	using System.Collections;
14	using System.Data;
15	using DataTypeTestClasses;
16	using Microsoft.Extensions.DependencyInjection;
17	using Microsoft.Extensions.Hosting;
18	using Microsoft.Extensions.Logging;
19
20	namespace QueryTests
21	{
22	····[TestFixture]
23	····public class NDOQueryTests
24	····{
25	········PersistenceManager pm;
26	········string mitarbeiterFields;
27	········string mitarbeiterJoinFields;
28	········string belegFields;
29	········string pkwFahrtFields;
30	········string reiseJoinFields;
31	········// Keep this variable, because it holds the serviceProvider during the test;
32	········IServiceProvider serviceProvider;
33
34
35	········[SetUp]
36	········public void SetUp()
37	········{
38	········}
39
40
41	········void Build( Action<IServiceCollection> configure = null )
42	········{
43	············var builder = Host.CreateDefaultBuilder();
44	············builder.ConfigureServices( services =>
45	············{
46	················services.AddLogging( b =>
47	················{
48	····················b.ClearProviders();
49	····················b.AddConsole();
50	················} );
51
52	················services.AddNdo( null, null );
53	················if (configure != null)
54	····················configure( services );
55	············} );
56
57	············var host = builder.Build();
58	············this.serviceProvider = host.Services;
59	············host.Services.UseNdo();
60
61	············this.pm = NDOFactory.Instance.PersistenceManager;
62
63	············mitarbeiterFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ) ).SelectList;
64	············mitarbeiterJoinFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ) ).Result( false, false, true );
65	············belegFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Beleg ) ) ).SelectList;
66	············this.pkwFahrtFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( PKWFahrt ) ) ).SelectList;
67	············this.reiseJoinFields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Reise ) ) ).Result( false, false, true );
68	········}
69
70
71	········[TearDown]
72	········public void TearDown()
73	········{
74	//var pm = NDOFactory. Instance. PersistenceManager;
75	//pm. Delete( pm. Objects<Mitarbeiter>( ) . ResultTable ) ;
76	//pm. Save( ) ;
77	········}
78
79
80	········[Test]
81	········public void QueryWithEmptyGuidParameterSearchesForNull()
82	········{
83	············Build();
84	············// The query will fetch for DataContainerDerived objects, too.
85	············// Hence we test with "StartsWith", because the query contains additional text, which doesn't matter here.
86	············var q = new NDOQuery<DataContainer>(pm, "guidVar = {0}");
87	············q.Parameters.Add( Guid.Empty );
88	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( DataContainer ) ) ).SelectList;
89	············var sql = $"SELECT {fields} FROM [DataContainer] WHERE [DataContainer].[GuidVar] IS NULL";
90	············Assert.That( q.GeneratedQuery.StartsWith( sql ) );
91
92	············q = new NDOQuery<DataContainer>(pm, "guidVar <> {0}");
93	············q.Parameters.Add( Guid.Empty );
94	············sql = $"SELECT {fields} FROM [DataContainer] WHERE [DataContainer].[GuidVar] IS NOT NULL";
95	············Assert.That( q.GeneratedQuery.StartsWith( sql ) );
96	········}
97
98	········[Test]
99	········public void QueryWithDateTimeMinValueParameterSearchesForNull()
100	········{
101	············Build();
102	············// The query will fetch for DataContainerDerived objects, too.
103	············// Hence we test with "StartsWith", because the query contains additional text, which doesn't matter here.
104	············var q = new NDOQuery<DataContainer>(pm, "dateTimeVar = {0}");
105	············q.Parameters.Add( DateTime.MinValue );
106	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( DataContainer ) ) ).SelectList;
107	············var sql = $"SELECT {fields} FROM [DataContainer] WHERE [DataContainer].[DateTimeVar] IS NULL";
108	············Assert.That( q.GeneratedQuery.StartsWith( sql ) );
109
110	············q = new NDOQuery<DataContainer>(pm, "dateTimeVar <> {0}");
111	············q.Parameters.Add( DateTime.MinValue );
112	············sql = $"SELECT {fields} FROM [DataContainer] WHERE [DataContainer].[DateTimeVar] IS NOT NULL";
113	············Assert.That( q.GeneratedQuery.StartsWith( sql ) );
114
115	········}
116
117	········[Test]
118	········public void CheckIfQueryWithoutWhereClauseWorks()
119	········{
120	············Build();
121	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
122	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter]", this.mitarbeiterFields ) == q.GeneratedQuery );
123	········}
124
125	········[Test]
126	········public void CheckIfSimplePrefetchWorks()
127	········{
128	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
129	············q.AddPrefetch( "dieReisen" );
130	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter]", this.mitarbeiterFields ) == q.GeneratedQuery );
131	········}
132
133	········public void CheckMitarbeiterQuery()
134	········{
135	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
136	············List<Mitarbeiter> l = q.Execute();
137	············Assert.That( 2 == l.Count );
138	········}
139
140	········[Test]
141	········public void CheckIfSimpleWhereClauseWorks()
142	········{
143	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = 'Mirko'" );
144	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'Mirko'", this.mitarbeiterFields ) == q.GeneratedQuery );
145	············q = new NDOQuery<Mitarbeiter>( pm, "vorname LIKE 'M*'" );
146	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] LIKE 'M*'", this.mitarbeiterFields ) == q.GeneratedQuery );
147	············q = new NDOQuery<Mitarbeiter>( pm, "oid = 1" );
148	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[ID] = 1", this.mitarbeiterFields ) == q.GeneratedQuery );
149	············q = new NDOQuery<Mitarbeiter>( pm, "oid(0) = 1" );
150	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[ID] = 1", this.mitarbeiterFields ) == q.GeneratedQuery );
151	········}
152
153	········[Test]
154	········public void CheckIfFunctionsWork()
155	········{
156	············Build();
157	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = SqlFunction('Mirko')" );
158	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = SqlFunction('Mirko')", this.mitarbeiterFields ) == q.GeneratedQuery );
159	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = SqlFunction('Mirko', 42)" );
160	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = SqlFunction('Mirko', 42)", this.mitarbeiterFields ) == q.GeneratedQuery );
161	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = SqlFunction()" );
162	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = SqlFunction()", this.mitarbeiterFields ) == q.GeneratedQuery );
163	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = SqlFunction(nachname)" );
164	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = SqlFunction([Mitarbeiter].[Nachname])", this.mitarbeiterFields ) == q.GeneratedQuery );
165	············q = new NDOQuery<Mitarbeiter>( pm, "SqlFunction('Mirko', 42) > 3124" );
166	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE SqlFunction('Mirko', 42) > 3124", this.mitarbeiterFields ) == q.GeneratedQuery );
167	········}
168
169	········[Test]
170	········public void CheckIfGeneratedQueryCanBeCalledTwice()
171	········{
172	············Build();
173	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = 'Mirko'" );
174	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'Mirko'", this.mitarbeiterFields ) == q.GeneratedQuery );
175	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'Mirko'", this.mitarbeiterFields ) == q.GeneratedQuery );
176	········}
177
178	········[Test]
179	········[TestCase( true )]
180	········[TestCase( false )]
181	········public void SkipTakeParametersDontChangeTheCoreQuery(bool asc)
182	········{
183	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
184	············q.Parameters.Add( "Mirko" );
185	············if (asc)
186	················q.Orderings.Add( new AscendingOrder( "vorname" ) );
187	············else
188	················q.Orderings.Add( new DescendingOrder( "vorname" ) );
189	············q.Take = 10;
190	············var desc = asc ? "" : "DESC ";
191	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] {desc}OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
192	············q.Skip = 10;
193	············q.Take = 10;
194	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] {desc}OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
195	········}
196
197	········[Test]
198	········public void MixedOrderingsWork()
199	········{
200	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
201	············q.Parameters.Add( "Mirko" );
202	············q.Orderings.Add( new AscendingOrder( "vorname" ) );
203	············q.Orderings.Add( new DescendingOrder( "nachname" ) );
204	············q.Take = 10;
205	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] ASC, [Mitarbeiter].[Nachname] DESC OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
206	············q.Skip = 10;
207	············q.Take = 10;
208	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] ASC, [Mitarbeiter].[Nachname] DESC OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
209	········}
210
211	········[Test]
212	········public void OrderingByOidWorks()
213	········{
214	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
215	············q.Parameters.Add( "Mirko" );
216	············q.Orderings.Add( new AscendingOrder( "oid" ) );
217	············q.Take = 10;
218	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[ID] OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
219	············q.Skip = 10;
220	············q.Take = 10;
221	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[ID] OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
222
223	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
224	············q.Parameters.Add( "Mirko" );
225	············q.Orderings.Add( new DescendingOrder( "oid" ) );
226	············q.Take = 10;
227	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[ID] DESC OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
228	············q.Skip = 10;
229	············q.Take = 10;
230	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[ID] DESC OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
231	········}
232
233	········[Test]
234	········[TestCase( true )]
235	········[TestCase( false )]
236	········public void ParametersChangesDontChangeTheCoreQuery(bool asc)
237	········{
238	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" );
239	············if (asc)
240	················q.Orderings.Add( new AscendingOrder( "vorname" ) );
241	············else
242	················q.Orderings.Add( new DescendingOrder( "vorname" ) );
243	············q.Take = 10;
244	············q.Parameters.Add( "Mirko" );
245	············var desc = asc ? "" : "DESC ";
246	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] {desc}OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
247	············q.Parameters.Add( "Hans" );
248	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = {{0}} ORDER BY [Mitarbeiter].[Vorname] {desc}OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY" == q.GeneratedQuery );
249	········}
250
251	········[Test]
252	········public void CheckIfWhereClauseWith1nRelationWorks()
253	········{
254	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.zweck = 'ADC'" );
255	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[Zweck] = 'ADC'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
256	············q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.oid = {0}" );
257	············q.Parameters.Add( 1 );
258	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[ID] = {{0}}", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
259	········}
260
261	········[Test]
262	········public void CheckIfWhereClauseWith11RelationWorks()
263	········{
264	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse.lkz LIKE 'D%'" );
265	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Adresse] ON [Adresse].[ID] = [Mitarbeiter].[IDAdresse] WHERE [Adresse].[Lkz] LIKE 'D%'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
266	········}
267
268	········[Test]
269	········public void CheckIfMultipleRelationsWork()
270	········{
271	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse.lkz LIKE 'D%' AND dieReisen.dieLaender.name = 'D'" );
272	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Adresse] ON [Adresse].[ID] = [Mitarbeiter].[IDAdresse] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] INNER JOIN [relLandReise] ON [Reise].[ID] = [relLandReise].[IDReise] INNER JOIN [Land] ON [Land].[ID] = [relLandReise].[IDLand] WHERE [Adresse].[Lkz] LIKE 'D%' AND [Land].[Name] = 'D'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
273	········}
274
275	········[Test]
276	········public void CheckOidWithTable()
277	········{
278	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.dieLaender.oid = {0}" );
279	············q.Parameters.Add( 1 );
280	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] INNER JOIN [relLandReise] ON [Reise].[ID] = [relLandReise].[IDReise] WHERE [relLandReise].[IDLand] = {{0}}", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
281	········}
282
283	········[Test]
284	········public void CheckThatOneJoinAppearsOnlyOneTime()
285	········{
286	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse.lkz LIKE 'D%' AND adresse.ort <> 'Bad Tölz'" );
287	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Adresse] ON [Adresse].[ID] = [Mitarbeiter].[IDAdresse] WHERE [Adresse].[Lkz] LIKE 'D%' AND [Adresse].[Ort] <> 'Bad Tölz'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
288	············q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.zweck = 'ADC' OR dieReisen.zweck = 'ADW'" );
289	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[Zweck] = 'ADC' OR [Reise].[Zweck] = 'ADW'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
290	········}
291
292	········[Test]
293	········public void CheckNotOperator()
294	········{
295	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "NOT (vorname LIKE 'M%')" );
296	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE NOT ([Mitarbeiter].[Vorname] LIKE 'M%')", this.mitarbeiterFields ) == q.GeneratedQuery );
297	············q = new NDOQuery<Mitarbeiter>( pm, "vorname LIKE 'M%' AND NOT nachname = 'Matytschak'" );
298	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] LIKE 'M%' AND NOT [Mitarbeiter].[Nachname] = 'Matytschak'", this.mitarbeiterFields ) == q.GeneratedQuery );
299	············q = new NDOQuery<Mitarbeiter>( pm, "NOT (vorname LIKE 'M%' AND nachname = 'Matytschak')" );
300	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] WHERE NOT ([Mitarbeiter].[Vorname] LIKE 'M%' AND [Mitarbeiter].[Nachname] = 'Matytschak')", this.mitarbeiterFields ) == q.GeneratedQuery );
301	············q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.zweck = 'ADC' OR NOT dieReisen.zweck = 'ADW'" );
302	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[Zweck] = 'ADC' OR NOT [Reise].[Zweck] = 'ADW'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
303	············q = new NDOQuery<Mitarbeiter>( pm, "NOT (dieReisen.zweck = 'ADC' OR dieReisen.zweck = 'ADW')" );
304	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE NOT ([Reise].[Zweck] = 'ADC' OR [Reise].[Zweck] = 'ADW')", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
305	············bool thrown = false;
306	············try
307	············{
308	················q = new NDOQuery<Mitarbeiter>( pm, "vorname LIKE 'M%' AND nachname = NOT 'Matytschak'" );
309	················string s = q.GeneratedQuery;
310	············}
311	············catch (OqlExpressionException)
312	············{
313	················thrown = true;
314	············}
315	············Assert.That( thrown );
316
317	············// TODO: This is a wrong expression which passes the syntax check.
318	············// Mysql allows WHERE NOT True but disallows nachname = NOT True
319	············// Sql Server doesn't know the symbol True
320	············q = new NDOQuery<Mitarbeiter>( pm, "vorname LIKE 'M%' AND nachname = NOT True" );
321	············string t = q.GeneratedQuery; // Make sure, GeneratedQuery ist called twice.
322	············Console.WriteLine(t);
323	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] LIKE 'M%' AND [Mitarbeiter].[Nachname] = NOT TRUE" == q.GeneratedQuery );
324	········}
325
326	········[Test]
327	········public void CheckBetween()
328	········{
329	············Build();
330	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname BETWEEN 'A' AND 'B'" );
331	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] BETWEEN 'A' AND 'B'" == q.GeneratedQuery );
332	············q = new NDOQuery<Mitarbeiter>( pm, "NOT vorname BETWEEN 'A' AND 'B'" );
333	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE NOT [Mitarbeiter].[Vorname] BETWEEN 'A' AND 'B'" == q.GeneratedQuery );
334	············q = new NDOQuery<Mitarbeiter>( pm, "NOT (vorname BETWEEN 'A' AND 'B')" );
335	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE NOT ([Mitarbeiter].[Vorname] BETWEEN 'A' AND 'B')" == q.GeneratedQuery );
336	········}
337
338	········[Test]
339	········public void TestValueType()
340	········{
341	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "position.X > 2 AND position.Y < 5" );
342	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Position_X] > 2 AND [Mitarbeiter].[Position_Y] < 5" == q.GeneratedQuery );
343	········}
344
345	········[Test]
346	········public void TestValueTypeRelation()
347	········{
348	············NDOQuery<Sozialversicherungsnummer> q = new NDOQuery<Sozialversicherungsnummer>( pm, "arbeiter.position.X > 2 AND arbeiter.position.Y < 5" );
349	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Sozialversicherungsnummer ) ) ).Result( false, false, true );
350	············Assert.That( String.Format( $"SELECT {fields} FROM [Sozialversicherungsnummer] INNER JOIN [Mitarbeiter] ON [Mitarbeiter].[ID] = [Sozialversicherungsnummer].[IDSozial] WHERE [Mitarbeiter].[Position_X] > 2 AND [Mitarbeiter].[Position_Y] < 5", this.mitarbeiterFields ) == q.GeneratedQuery );
351	········}
352
353	········[Test]
354	········public void CheckFetchGroupInitializationWithExpressions()
355	········{
356	············Build();
357	············FetchGroup<Mitarbeiter> fg = new FetchGroup<Mitarbeiter>( m => m.Vorname, m => m.Nachname );
358	············Assert.That( fg.Count == 2, "Count should be 2" );
359	············Assert.That( "Vorname" == fg[0], "Name wrong #1" );
360	············Assert.That( "Nachname" == fg[1], "Name wrong #2" );
361	········}
362
363	········[Test]
364	········public void CheckIfSyntaxErrorThrowsAQueryException()
365	········{
366	············bool qeThrown = false;
367	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname IN 'Mirko'" );
368	············try
369	············{
370	················var s = q.GeneratedQuery;
371	············}
372	············catch (OqlExpressionException)
373	············{
374	················qeThrown = true;
375	············}
376
377	············Assert.That( qeThrown, "Syntax Error should throw an OqlExpressionException" );
378	········}
379
380	········[Test]
381	········public void CheckIfMultiKeysWork()
382	········{
383	············NDOQuery<OrderDetail> q = new NDOQuery<OrderDetail>( pm, "oid = {0}" );
384	············var od = pm.FindObject(typeof(OrderDetail), new object[]{ 1, 2 } );
385	············q.Parameters.Add( od.NDOObjectId );
386	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( OrderDetail ) ) ).SelectList;
387	············Assert.That( $"SELECT {fields} FROM [OrderDetail] WHERE [OrderDetail].[IDProduct] = {{0}} AND [OrderDetail].[IDOrder] = {{1}}" == q.GeneratedQuery );
388	············bool thrown = false;
389	············try
390	············{
391	················q = new NDOQuery<OrderDetail>( pm, "oid = -4" );
392	················string s = q.GeneratedQuery;
393	············}
394	············catch (NDOException)
395	············{
396	················thrown = true;
397	············}
398	············Assert.That( thrown );
399	········}
400
401	········[Test]
402	········public void CheckIfMultiKeyObjectIdParametersAreProcessed()
403	········{
404	············IList generatedParameters = null;
405	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
406	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
407
408	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
409
410	············NDOQuery<OrderDetail> q = new NDOQuery<OrderDetail>( pm, "oid = {0}" );
411	············ObjectId oid = pm.FindObject( typeof( OrderDetail ), new object[] { 1, 2 } ).NDOObjectId;
412	············q.Parameters.Add( oid );
413
414	············q.Execute();
415
416	············Assert.That( generatedParameters != null );
417	············Assert.That( 2 == generatedParameters.Count );
418	············Assert.That( 1 == (int) generatedParameters[0] );
419	············Assert.That( 2 == (int) generatedParameters[1] );
420	········}
421
422	········[Test]
423	········public void CheckIfMultiKeyArrayParametersAreProcessed()
424	········{
425	············IList generatedParameters = null;
426	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
427	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
428	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
429
430	············NDOQuery<OrderDetail> q = new NDOQuery<OrderDetail>( pm, "oid = {0}" );
431	············q.Parameters.Add( new object[] { 1, 2 } );
432	············q.Execute();
433	············Assert.That( generatedParameters != null );
434	············Assert.That( 2 == generatedParameters.Count );
435	············Assert.That( 1 == (int) generatedParameters[0] );
436	············Assert.That( 2 == (int) generatedParameters[1] );
437	········}
438
439
440	········[Test]
441	········public void CheckIfSingleKeyOidParameterIsProcessed()
442	········{
443	············IList generatedParameters = null;
444	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
445	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
446	············var handler = handlerMock.Object;
447	············Mock<IPersistenceHandlerManager> phManagerMock = new Mock<IPersistenceHandlerManager>();
448	············phManagerMock.Setup( m => m.GetPersistenceHandler( It.IsAny<Type>() ) ).Returns( handler ).Callback<Type>( ( pc ) => { Console.WriteLine("Test"); });
449	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
450
451	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "oid = {0}" );
452	············q.Parameters.Add( 1 );
453	············q.Execute();
454	············Assert.That( generatedParameters··!= null );
455	············Assert.That( 1 == generatedParameters.Count );
456	············Assert.That( 1 == (int) generatedParameters[0] );
457	········}
458
459	········[Test]
460	········public void CheckIfSqlQueryIsProcessed()
461	········{
462	············IList generatedParameters = null;
463	············string expression = null;
464	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
465	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => { generatedParameters = l; expression = s; } );
466	············var handler = handlerMock.Object;
467	············Mock<IPersistenceHandlerManager> phManagerMock = new Mock<IPersistenceHandlerManager>();
468	············phManagerMock.Setup( m => m.GetPersistenceHandler( It.IsAny<Type>() ) ).Returns( handler );
469	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
470
471	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "SELECT * FROM Mitarbeiter WHERE ID = {0}", false, QueryLanguage.Sql );
472	············q.Parameters.Add( 1 );
473	············q.Execute();
474	············Assert.That( generatedParameters··!= null );
475	············Assert.That( 1 == generatedParameters.Count );
476	············Assert.That( 1 == (int) generatedParameters[0] );
477	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM Mitarbeiter WHERE ID = {{0}}" == expression );
478	········}
479
480	········[Test]
481	········public void CheckIfSingleKeyNDOObjectIdParameterIsProcessed()
482	········{
483	············IList generatedParameters = null;
484	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
485	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
486	············var handler = handlerMock.Object;
487	············Mock<IPersistenceHandlerManager> phManagerMock = new Mock<IPersistenceHandlerManager>();
488	············phManagerMock.Setup( m => m.GetPersistenceHandler( It.IsAny<Type>() ) ).Returns( handler ).Callback<Type>( ( pc ) => { Console.WriteLine( "Test" ); } );
489	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
490
491
492	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "oid = {0}" );
493	············var dummy = (IPersistenceCapable) pm.FindObject( typeof( Mitarbeiter ), 121 );
494	············q.Parameters.Add( dummy.NDOObjectId );
495	············q.Execute();
496	············Assert.That( generatedParameters··!= null );
497	············Assert.That( 1 == generatedParameters.Count );
498	············Assert.That( 121 == (int) generatedParameters[0] );
499	········}
500
501	········[Test]
502	········public void SimpleQueryWithHandler()
503	········{
504	············IList generatedParameters = null;
505	············Mock<IPersistenceHandler> handlerMock = new Mock<IPersistenceHandler>();
506	············handlerMock.Setup( h => h.PerformQuery( It.IsAny<string>(), It.IsAny<IList>(), It.IsAny<DataSet>() ) ).Returns( new DataTable() ).Callback<string, IList, DataSet>( ( s, l, d ) => generatedParameters = l );
507	············var handler = handlerMock.Object;
508	············Mock<IPersistenceHandlerManager> phManagerMock = new Mock<IPersistenceHandlerManager>();
509	············phManagerMock.Setup( m => m.GetPersistenceHandler( It.IsAny<Type>() ) ).Returns( handler ).Callback<Type>( ( pc ) => { Console.WriteLine( "Test" ); } );
510	············Build( serviceCollection => serviceCollection.AddSingleton( handlerMock.Object ) );
511
512	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
513	············q.Execute();
514	············Assert.That( generatedParameters··!= null );
515	············Assert.That( 0 == generatedParameters.Count );
516	········}
517
518	········[Test]
519	········public void TestSuperclasses()
520	········{
521	············NDOQuery<Kostenpunkt> qk = new NDOQuery<Kostenpunkt>( pm );
522	············Assert.That( $"SELECT {this.belegFields} FROM [Beleg];\r\nSELECT {this.pkwFahrtFields} FROM [PKWFahrt]" == qk.GeneratedQuery );
523	········}
524
525	········[Test]
526	········public void TestPolymorphicRelationQueries()
527	········{
528	············NDOQuery<Reise> q = new NDOQuery<Reise>( pm, "belege.datum = {0}" );
529	············q.Parameters.Add( DateTime.Now );
530	············Assert.That( $"SELECT {reiseJoinFields} FROM [Reise] INNER JOIN [relBelegKostenpunkt] ON [Reise].[ID] = [relBelegKostenpunkt].[IDReise] INNER JOIN [Beleg] ON [Beleg].[ID] = [relBelegKostenpunkt].[IDBeleg] AND [relBelegKostenpunkt].[TCBeleg] = 926149172 WHERE [Beleg].[Datum] = {{0}} UNION \r\nSELECT {reiseJoinFields} FROM [Reise] INNER JOIN [relBelegKostenpunkt] ON [Reise].[ID] = [relBelegKostenpunkt].[IDReise] INNER JOIN [PKWFahrt] ON [PKWFahrt].[ID] = [relBelegKostenpunkt].[IDBeleg] AND [relBelegKostenpunkt].[TCBeleg] = 734406058 WHERE [PKWFahrt].[Datum] = {{0}}" == q.GeneratedQuery );
531	········}
532
533	········[Test]
534	········public void Test1To1()
535	········{
536	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "meinBuero.zimmer = 'abc'" );
537	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Buero] ON [Buero].[ID] = [Mitarbeiter].[IDBuero] WHERE [Buero].[Zimmer] = 'abc'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
538	········}
539
540
541	········[Test]
542	········public void Test1To1Bidirectional()
543	········{
544	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "sn.nummer = 4711" );
545	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [Sozialversicherungsnummer] ON [Sozialversicherungsnummer].[ID] = [Mitarbeiter].[IDSozial] WHERE [Sozialversicherungsnummer].[Nummer] = 4711", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
546	············NDOQuery<Sozialversicherungsnummer> qs = new NDOQuery<Sozialversicherungsnummer>( pm, "arbeiter.vorname = 'Mirko'" );
547	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Sozialversicherungsnummer ) ) ).Result( false, false, true );
548	············Assert.That( $"SELECT {fields} FROM [Sozialversicherungsnummer] INNER JOIN [Mitarbeiter] ON [Mitarbeiter].[ID] = [Sozialversicherungsnummer].[IDSozial] WHERE [Mitarbeiter].[Vorname] = 'Mirko'" == qs.GeneratedQuery );
549	········}
550
551	········[Test]
552	········public void Test1To1BiWithTable()
553	········{
554	············NDOQuery<Zertifikat> qz = new NDOQuery<Zertifikat>( pm, "sgn.signature = 'abc'" );
555	············var fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Zertifikat ) ) ).Result( false, false, true );
556	············Assert.That( $"SELECT {fields} FROM [Zertifikat] INNER JOIN [relSignaturZertifikat] ON [Zertifikat].[ID] = [relSignaturZertifikat].[IDZertifikat] INNER JOIN [Signatur] ON [Signatur].[ID] = [relSignaturZertifikat].[IDSignatur] WHERE [Signatur].[Signature] = 'abc'" == qz.GeneratedQuery );
557	············NDOQuery<Signatur> qs = new NDOQuery<Signatur>( pm, "owner.schlüssel = -4" );
558	············string s = qs.GeneratedQuery;
559	············fields = new SqlColumnListGenerator( pm.NDOMapping.FindClass( typeof( Signatur ) ) ).Result( false, false, true );
560	············Assert.That( $"SELECT {fields} FROM [Signatur] INNER JOIN [relSignaturZertifikat] ON [Signatur].[ID] = [relSignaturZertifikat].[IDSignatur] INNER JOIN [Zertifikat] ON [Zertifikat].[ID] = [relSignaturZertifikat].[IDZertifikat] WHERE [Zertifikat].[Schlüssel] = -4" == qs.GeneratedQuery );
561	········}
562
563	········[Test]
564	········public void Test1ToNWithTable()
565	········{
566	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "reiseBüros.name = 'abc'" );
567	············Assert.That( String.Format( "SELECT {0} FROM [Mitarbeiter] INNER JOIN [relMitarbeiterReisebuero] ON [Mitarbeiter].[ID] = [relMitarbeiterReisebuero].[IDMitarbeiter] INNER JOIN [Reisebuero] ON [Reisebuero].[ID] = [relMitarbeiterReisebuero].[IDReisebuero] WHERE [Reisebuero].[Name] = 'abc'", this.mitarbeiterJoinFields ) == q.GeneratedQuery );
568	········}
569
570	········[Test]
571	········public void TestIfQueryForNonNullOidsWorks()
572	········{
573	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.dieLaender.oid IS NOT NULL" );
574	············Assert.That( $"SELECT {this.mitarbeiterJoinFields} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] INNER JOIN [relLandReise] ON [Reise].[ID] = [relLandReise].[IDReise] WHERE [relLandReise].[IDLand] IS NOT NULL" == q.GeneratedQuery );
575	········}
576
577	········[Test]
578	········public void TestIfQueryWithNonNullRelationWorks()
579	········{
580	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse IS NOT NULL" );
581	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[IDAdresse] IS NOT NULL" == q.GeneratedQuery );
582	········}
583
584	········[Test]
585	········public void TestIfQueryWithNullRelationWorks()
586	········{
587	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "adresse IS NULL" );
588	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[IDAdresse] IS NULL" == q.GeneratedQuery );
589	········}
590
591	········[Test]
592	········public void TestIfInClauseWorks()
593	········{
594	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname IN (1,2,3,4,5)" );
595	············var s = q.GeneratedQuery;
596	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] IN (1, 2, 3, 4, 5)" == s );
597	········}
598
599	········[Test]
600	········public void TestIfInClauseWithStringsWorks()
601	········{
602	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname IN ('1','2','3','4','5')" );
603	············var s = q.GeneratedQuery;
604	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] IN ('1', '2', '3', '4', '5')" == s );
605	········}
606
607	········[Test]
608	········public void TestIfSingleQuotesAreForbidden()
609	········{
610	············// -- will be interpreted as NDOql comment
611	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname = 'lala'--SELECT * FROM Mitarbeiter'" );
612	············var s = q.GeneratedQuery;
613	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'lala'" == s );
614
615	············// -SELECT * FROM is a valid expression, it would result in a sql error
616	············// Mitarbeiter is a syntax error, so the expression is recognized as incorrect from the 33rd character onwards
617	············q = new NDOQuery<Mitarbeiter>( pm, "vorname = 'lala' -SELECT * FROM Mitarbeiter'" );
618	············try
619	············{
620	················s = q.GeneratedQuery;
621	············}
622	············catch (OqlExpressionException)
623	············{
624	················// Expected outcome
625	············}
626	········}
627
628	········[Test]
629	········public void TestIfInClauseWithQuotesInStringsWorks()
630	········{
631	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "vorname IN ('1''','2''3','''3','4','5')" );
632	············var s = q.GeneratedQuery;
633	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] IN ('1''', '2''3', '''3', '4', '5')" == s );
634	········}
635
636	········[Test]
637	········public void TestIfRelationInInClauseWorks()
638	········{
639	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "dieReisen.oid IN (1,2,3,4,5)" );
640	············var s = q.GeneratedQuery;
641	············Assert.That( $"SELECT {this.mitarbeiterJoinFields} FROM [Mitarbeiter] INNER JOIN [Reise] ON [Mitarbeiter].[ID] = [Reise].[IDMitarbeiter] WHERE [Reise].[ID] IN (1, 2, 3, 4, 5)" == s );
642	········}
643
644	········[Test]
645	········public void TestIfOidWithInClauseWorks()
646	········{
647	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "oid IN (1,2,3,4,5)" );
648	············var s = q.GeneratedQuery;
649	············Assert.That( $"SELECT {this.mitarbeiterFields} FROM [Mitarbeiter] WHERE [Mitarbeiter].[ID] IN (1, 2, 3, 4, 5)" == s );
650	········}
651
652	········[Test]
653	········public void TestIfSqlCodeWorks()
654	········{
655	············var expression = "SELECT * FROM Mitarbeiter WHERE Vorname = 'Mirko'";
656	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( this.pm, expression, false, QueryLanguage.Sql );
657	············Assert.That( expression == q.GeneratedQuery );
658	········}
659
660	········[Test]
661	········public void GreaterEqualsWorks()
662	········{
663	············var query = new NDOQuery<Mitarbeiter>( NDOFactory.Instance.PersistenceManager, "vorname >= {0} AND vorname < {1}" );
664	············query.Parameters.Add( "ab" );
665	············query.Parameters.Add( "abc" );
666	············query.Orderings.Add( new NDO.Query.DescendingOrder( "vorname" ) );
667	············Assert.That(query.GeneratedQuery.IndexOf( "[Mitarbeiter].[Vorname] >= {0}" ) > -1);
668	············Assert.That( query.GeneratedQuery.IndexOf( "[Mitarbeiter].[Vorname] < {1}" ) > -1 );
669	········}
670
671	········[Test]
672	········public void BitwiseOperatorsWork()
673	········{
674	············Build();
675	············var pm = NDOFactory.Instance.PersistenceManager;
676	············var query = new NDOQuery<Buero>( pm, "Nummer & 2 = 0" );
677	············Assert.That( query.GeneratedQuery.IndexOf( "[Buero].[Nummer] & 2 = 0" ) > -1 );
678	············query = new NDOQuery<Buero>( pm, "Nummer \| 2 = 0" );
679	············Assert.That( query.GeneratedQuery.IndexOf( "[Buero].[Nummer] \| 2 = 0" ) > -1 );
680	········}
681
682	········[Test]
683	········public void DirectDeleteQueryIsCorrect()
684	········{
685	············var q = new NDOQuery<Mitarbeiter>( NDOFactory.Instance.PersistenceManager, "vorname = 'Mirko'" );
686	············var sql = q.GetDirectDeleteQuery();
687	············Assert.That( "DELETE FROM [Mitarbeiter] WHERE [Mitarbeiter].[Vorname] = 'Mirko'" == sql );
688	········}
689
690	········[Test]
691	········public void TransientDelete()
692	········{
693	············var pm = NDOFactory.Instance.PersistenceManager;
694	············var m = new Mitarbeiter();
695	············try
696	············{
697	················pm.Delete( m );
698	············}
699	············catch (NDOException ex)
700	············{
701	················Assert.That( 120 == ex.ErrorNumber );
702	············}
703	········}
704	····}
705	}
706

Cookie Info