public static TModel FindOffset <TModel>(this IDbConnection cnn, int offset, object param = null, Expression <Func <TModel, object> > selector = null, IDbTransaction transaction = null) where TModel : ModelBase
{
QueryTest query = GetQuery(false, param, selector);
query.Query += "\n";
query.Query += $"order by (select null) offset {offset} rows fetch next 1 rows only";
return(cnn.Query <TModel>(query.Query, query.Param, transaction: transaction).FirstOrDefault());
}
/// <summary>
/// Show a message box and return result
/// </summary>
/// <param name="messageText"></param>
/// <param name="titleCaption"></param>
/// <param name="buttons"></param>
/// <param name="icon"></param>
/// <returns></returns>
///
public static DialogResult Show(
string messageText,
string titleCaption,
MessageBoxButtons buttons,
MessageBoxIcon icon,
int width = -1,
int height = -1)
{
DialogResult dr = DialogResult.OK;
if (!Lex.IsNullOrEmpty(ScriptLog.FileName))
{
ScriptLog.Message("> " + messageText);
}
if (!SS.I.Attended)
{
ClientLog.Message("Show: " + messageText);
return(DialogResult.OK);
}
else if (SS.I.QueryTestMode)
{
QueryTest.LogMessage("Show: " + messageText);
return(DialogResult.OK);
}
//DebugLog.Message(messageText += "\r\n" + new StackTrace(true)); // debug where message is called from"
Progress.Hide(); // hide any progress message
if (Lex.Contains(messageText, "<br>")) // replace "<br>" with newlines
{
messageText = messageText.Replace("<br>", "\r\n");
}
if (Lex.CountLines(messageText) > 5)
{
if (width <= 0)
{
width = 650;
}
if (height <= 0)
{
height = 400;
}
dr = ShowWithCustomSize(messageText, titleCaption, buttons, icon, width, height);
return(dr);
}
if (messageText.Length > 72 && !messageText.Contains("\r") && !messageText.Contains("\n"))
{
messageText = WrapText(messageText, 6000);
}
//icon = MessageBoxIcon.Information;
dr = XtraMessageBox.Show(messageText, titleCaption, buttons, icon);
return(dr);
}
public ResultListInfo <TestInfo> GetAll(QueryTest query)
{
var entites = this.context.testDb.Select.ToList();
return(new ResultListInfo <TestInfo>()
{
List = this.mapper.Map <List <TestInfo> >(entites)
});
}
private static QueryTest GetQuery <TModel>(bool is_topOne, object param = null, Expression <Func <TModel, object> > selector = null) where TModel : ModelBase
{
QueryTest query = new QueryTest();
string _selector = "*";
if (selector != null)
{
_selector = ExpressionToSql.Select <TModel>(selector);
}
query.Query = string.Format("select {0} {1} from dbo.[{2}]", (is_topOne) ? "top 1" : "", _selector, GetTableName <TModel>());
query.Param = null;
if (param != null)
{
object parameters = param;
IEnumerable <PropertyInfo> properties = parameters.GetType().GetProperties();
query.Query += " where ";
int j = 0;
if (properties.Count() > 0 && !(parameters is string))
{
foreach (PropertyInfo property in properties)
{
if (j > 0)
{
query.Query += " and ";
}
query.Query += string.Format("[{0}] = @{0}", property.Name);
j++;
}
query.Param = param;
}
else
{
properties = KeyPropertiesCache(typeof(TModel));
if (properties.Count() > 1)
{
List <string> keys = (from x in properties select x.Name).ToList <string>();
throw new ArgumentException(string.Format("O modelo ({0}) tem mais de uma propriedade [Key] ('{1}'), não é possível localizar o registro com uma única informação [Key]", GetTableName <TModel>(), string.Join(",", keys.ToArray())));
}
PropertyInfo property = properties.FirstOrDefault();
query.Query += string.Format("[{0}] = @{0}", property.Name);
DynamicParameters dynamicParameters = new DynamicParameters();
dynamicParameters.Add(string.Format("@{0}", property.Name), parameters);
query.Param = dynamicParameters;
}
}
return(query);
}
public static int Count <TModel>(this IDbConnection cnn, object param = null, IDbTransaction transaction = null) where TModel : ModelBase
{
QueryTest query = GetPredicate <TModel>(param);
IEnumerable <PropertyInfo> keyProperties = KeyPropertiesCache(typeof(TModel));
string sql = string.Format("select top 1 count(1) from dbo.[{0}]", GetTableName <TModel>());
if (!string.IsNullOrEmpty(query.Condition))
{
sql += " where " + query.Condition;
}
return(cnn.Query <int>(sql, query.Param, transaction: transaction).FirstOrDefault());
}
public async Task Mediator_AoEnviarQuery_RetornarOK()
{
// Arrange
var query = new QueryTest();
_mocker.GetMock <IMediator>()
.Setup(x => x.Send(It.IsAny <Query>(), CancellationToken.None))
.Returns(Task.FromResult(new ResponseResult()));
// Act
var responseResult = await _handler.RequestQuery(query);
// Assert
_mocker.GetMock <IMediator>().Verify(x => x.Send(It.IsAny <Query>(), CancellationToken.None), Times.Once);
}
private static QueryTest GetPredicate <TModel>(dynamic param) where TModel : ModelBase
{
QueryTest query = new QueryTest();
Type type = typeof(TModel);
IEnumerable <PropertyInfo> keyProperties = KeyPropertiesCache(type);
query.Param = null;
if (param != null)
{
object parameters = param;
IEnumerable <PropertyInfo> properties = parameters.GetType().GetProperties();
int j = 0;
if (properties.Count() > 0 && !(parameters is string))
{
foreach (PropertyInfo property in properties)
{
if (j > 0)
{
query.Condition += " and ";
}
query.Condition += string.Format("[{0}] = @{0}", property.Name);
j++;
}
query.Param = param;
}
else
{
properties = KeyPropertiesCache(typeof(TModel));
if (properties.Count() > 1)
{
throw new ArgumentException(string.Format("O modelo ({0}) tem mais de uma propriedade [Key], não é possível localizar o registro com uma única informação [Key]", GetTableName <TModel>()));
}
PropertyInfo property = properties.FirstOrDefault();
query.Condition += string.Format("[{0}] = @{0}", property.Name);
DynamicParameters dynamicParameters = new DynamicParameters();
dynamicParameters.Add(string.Format("@{0}", property.Name), parameters);
query.Param = dynamicParameters;
}
}
return(query);
}
public void Query(SerializableTest wrapper)
{
QueryTest test = wrapper.Test.Query;
if (test.IsError)
{
var exception = Assert.ThrowsAny <Exception>(() => BuildQuery());
Assert.True(exception is ArgumentException || exception is InvalidOperationException, $"Exception type: {exception.GetType()}");
}
else
{
var query = BuildQuery();
Assert.Equal(test.Query, query.ToStructuredQuery());
}
Query BuildQuery()
{
Query query = GetCollectionReference(test.CollPath);
foreach (var clause in test.Clauses)
{
switch (clause.ClauseCase)
{
case Clause.ClauseOneofCase.EndAt:
query = query.EndAt(ConvertCursor(clause.EndAt));
break;
case Clause.ClauseOneofCase.EndBefore:
query = query.EndBefore(ConvertCursor(clause.EndBefore));
break;
case Clause.ClauseOneofCase.Limit:
query = query.Limit(clause.Limit);
break;
case Clause.ClauseOneofCase.Offset:
query = query.Offset(clause.Offset);
break;
case Clause.ClauseOneofCase.OrderBy:
var ordering = clause.OrderBy;
var path = ConvertFieldPath(ordering.Path);
query = ordering.Direction == "asc" ? query.OrderBy(path) : query.OrderByDescending(path);
break;
case Clause.ClauseOneofCase.Select:
query = query.Select(clause.Select.Fields.Select(ConvertFieldPath).ToArray());
break;
case Clause.ClauseOneofCase.StartAfter:
query = query.StartAfter(ConvertCursor(clause.StartAfter));
break;
case Clause.ClauseOneofCase.StartAt:
query = query.StartAt(ConvertCursor(clause.StartAt));
break;
case Clause.ClauseOneofCase.Where:
var filterPath = ConvertFieldPath(clause.Where.Path);
if (!QueryOperators.TryGetValue(clause.Where.Op, out var filterProvider))
{
throw new ArgumentException($"Invalid where operator: {clause.Where.Op}");
}
var value = DeserializeJson(clause.Where.JsonValue);
query = filterProvider(query, filterPath, value);
break;
default:
throw new InvalidOperationException($"Unexpected clause case: {clause.ClauseCase}");
}
}
return(query);
}
// Note: dynamic to allow a DocumentSnapshot to be returned and used in overload resolution.
dynamic ConvertCursor(Cursor cursor)
{
var docSnapshot = cursor.DocSnapshot;
if (docSnapshot == null)
{
return(cursor.JsonValues.Select(DeserializeJson).ToArray());
}
var docRef = GetDocumentReference(docSnapshot.Path);
return(DocumentSnapshot.ForDocument(
docRef.Database,
new Document
{
Name = docRef.Path,
Fields = { ValueSerializer.SerializeMap(DeserializeJson(cursor.DocSnapshot.JsonData)) },
CreateTime = wkt::Timestamp.FromDateTimeOffset(DateTimeOffset.MinValue),
UpdateTime = wkt::Timestamp.FromDateTimeOffset(DateTimeOffset.MinValue),
},
Timestamp.FromDateTimeOffset(DateTimeOffset.MinValue)));
}
}
public static void Main(string[] args)
{
int n = 10;
Point[] klucha = new Point[2 * n];
QueryTest[] testyKluchy = new QueryTest[4 * n];
for (int i = 0; i < n; i++)
{
klucha[i] = new Point(6 * n - 6 * i, 2);
klucha[i + n] = new Point(6 * i + 3, 1);
}
for (int i = 0; i < 2 * n; i++)
{
testyKluchy[i] = new Program.QueryTest(3 * i + 5, 1.5, true);
testyKluchy[i + 2 * n] = new Program.QueryTest(3 * i + 5, 2.5 - 2 * (i % 2), false);
}
testyKluchy[2 * n - 2].answer = false;
testyKluchy[2 * n - 1] = new Program.QueryTest(3.5, 1.1, true);
Point[] glizda = new Point[2 * n];
QueryTest[] testyGlizdy = new Program.QueryTest[2 * n];
for (int i = 0; i < n; i++)
{
glizda[i] = new Point(3 * i + 2, 4 * n * i);
glizda[2 * n - i - 1] = new Point(3 * i, 4 * n * i);
if (i % 2 == 1)
{
glizda[i].x += 4 * n;
glizda[2 * n - i - 1].x += 4 * n;
}
}
for (int i = 0; i < n; i++)
{
if (i % 2 == 0)
{
testyGlizdy[i] = new Program.QueryTest(3 * i + 1, 4 * n * i + 0.1, true);
testyGlizdy[i + n] = new Program.QueryTest(3 * i + 1, 4 * n * i + 1.1, false);
}
else
{
testyGlizdy[i] = new Program.QueryTest(3 * i + 1 + 4 * n, 4 * n * i - 0.1, true);
testyGlizdy[i + n] = new Program.QueryTest(3 * i + 1 + 4 * n, 4 * n * i - 1.1, false);
}
}
Tester[] simpleTests =
{
new Tester(new Point[] {
new Point(5, 5),
new Point(-3, -1),
new Point(5, -1)
}, new QueryTest[] {
new QueryTest(-2, -0.5, true),
new QueryTest(2, -10, false),
new QueryTest(2, 10, false)
}),
new Tester(klucha, testyKluchy),
new Tester(glizda, testyGlizdy)
};
Tester[] advancedTests =
{
new Tester(new Point[] {
new Point(5, 5),
new Point(-3, -1),
new Point(5, -1)
}, new QueryTest[] {
new QueryTest(5, 5, true),
new QueryTest(-3, -1, true),
new QueryTest(5, -1, true),
new QueryTest(-5, -1, false),
new QueryTest(1, 2, true),
new QueryTest(1, -1, true),
new QueryTest(5, 6, false),
new QueryTest(5, 3, true),
new QueryTest(5, -3, false),
new QueryTest(6, 5, false)
})
};
Tester[] nastyTests =
{
new Tester(new Point[] {
new Point(10, 10),
new Point(0, 9),
new Point(20, 8),
new Point(0, 7),
new Point(1, 0),
new Point(2, 7),
new Point(3, 0),
new Point(4, 7),
new Point(5, 0),
new Point(6, 7),
new Point(7, 0),
new Point(8, 7),
new Point(25, 8),
new Point(10, 20),
new Point(20, 9),
new Point(0, 20),
new Point(1, 15),
new Point(2, 14),
new Point(3, 13),
new Point(4, 12),
new Point(5, 11),
new Point(6, 10)
}, new QueryTest[] {
new QueryTest(0, 9, true),
new QueryTest(2, 4, false),
new QueryTest(3, 5, true),
new QueryTest(4, 5, false),
new QueryTest(5, 9, true),
new QueryTest(5, 10, false),
new QueryTest(10, 10, true),
new QueryTest(10, 20, true),
new QueryTest(10, 25, false),
new QueryTest(10, 19, false),
new QueryTest(10, 13, true),
new QueryTest(10, 8, false),
new QueryTest(25, 8, true),
new QueryTest(25, 8.5, false),
new QueryTest(25.5, 8, false),
new QueryTest(3.1, 12.9, true),
new QueryTest(4.1, 11.9, true),
new QueryTest(4.1, 11.8, false)
})
};
Console.WriteLine("Podstawowe testy:\n");
runTestArray(simpleTests);
Console.WriteLine("\n\nZaawansowane testy:\n");
runTestArray(advancedTests);
Console.WriteLine("\n\nZlosliwe testy:\n");
runTestArray(nastyTests);
Console.WriteLine("\n\nTesty wydajnosci (poprawnosc nie sprawdzana): ");
int rozm = 1250000;
Polygon p = new Polygon(makeSpiralPolygon(rozm));
Console.WriteLine("\tSkonstruowano wielokat");
int tests = 10000;
Random rand = new Random(13);
for (int i = 0; i < tests; i++)
{
for (int j = 0; j < tests; j++)
{
p.ContainsPoint(i + 0.5, j + 0.5);
}
}
Console.WriteLine("\tZakonczono testy\n");
}
public bool RunTests()
{
return(QueryTest.DoTheTests(new Polygon(p), q));
}
public static IEnumerable <TModel> All <TModel>(this IDbConnection cnn, object param = null, Expression <Func <TModel, object> > selector = null, IDbTransaction transaction = null) where TModel : ModelBase
{
QueryTest query = GetQuery <TModel>(false, param as object, selector);
return(cnn.Query <TModel>(query.Query, query.Param, transaction: transaction));
}
public static TModel Find <TModel>(this IDbConnection cnn, object param, Expression <Func <TModel, object> > selector = null, IDbTransaction transaction = null) where TModel : ModelBase
{
QueryTest query = GetQuery(true, param, selector);
return(cnn.Query <TModel>(query.Query, query.Param, transaction: transaction).FirstOrDefault());
}
