public void MatchesPredicate_Constructor_SetsFieldObject()
{
var expectedFields = new TestPredicateFields();
var predicate = new ExistsPredicate <TestPredicateFields>(expectedFields);
Assert.AreSame(expectedFields, predicate.Fields);
}
internal gsWhereTermBase GetWhereTerm(ExistsPredicate existsPredicate, gsExistsOrNotExists existsOrNotExists)
{
gsWhereTermExistsOrNotExists whereTerm = new gsWhereTermExistsOrNotExists();
whereTerm.ExistsType = existsOrNotExists;
if (existsPredicate.Subquery.QueryExpression is QuerySpecification)
{
gsSelectQuery subQry = new gsSelectQuery();
subQry.QryName = $"subQry{gsSelectQuery.GetNextID()}";
whereTerm.QueryName = subQry.QryName;
QuerySpecification qrySpec = existsPredicate.Subquery.QueryExpression as QuerySpecification;
gsSelectQueryParser qryParser = new gsSelectQueryParser();
qryParser.ProcessQuerySpecification(qrySpec, subQry);
whereTerm.Sql = subQry.ToString();
}
else
{
throw new NotImplementedException($"QuerySpecification {existsPredicate.Subquery.QueryExpression.GetType().Name} not supported");
}
return(whereTerm);
}
public void MatchesPredicate_Constructor_SetsCaseSensitivity()
{
var fields = new TestPredicateFields();
var predicate = new ExistsPredicate <TestPredicateFields>(fields, isCaseSensitive: true);
Assert.IsTrue(predicate.IsCaseSensitive);
}
public QsiInvokeExpressionNode VisitExistsPredicate(ExistsPredicate existsPredicate)
{
return(TreeHelper.Create <QsiInvokeExpressionNode>(n =>
{
n.Member.SetValue(TreeHelper.CreateFunction(SqlServerKnownFunction.Exists));
n.Parameters.Add(VisitScalarSubquery(existsPredicate.Subquery));
}));
}
public override void Visit(ExistsPredicate node)
{
// count select star expressions in predicate
var childVisitor = new ChildVisitor();
node.AcceptChildren(childVisitor);
expressionCounter += childVisitor.SelectStarExpressionCount;
}
/// <summary>
/// This is a helper method that generates an if statement that checks the batches executed
/// table to see if the current batch has been executed. The if statement will look like this
///
/// if not exists(select 1 from [tempdb].[dbo].[$(CompletedBatches)]
/// where BatchId = batchId)
/// begin
/// end
/// </summary>
/// <param name="batchId"></param>
/// <returns></returns>
private static IfStatement CreateIfNotExecutedStatement(int batchId)
{
// Create the exists/select statement
ExistsPredicate existsExp = new ExistsPredicate();
ScalarSubquery subQuery = new ScalarSubquery();
existsExp.Subquery = subQuery;
subQuery.QueryExpression = new QuerySpecification
{
SelectElements =
{
new SelectScalarExpression {
Expression = new IntegerLiteral{
Value = "1"
}
}
},
FromClause = new FromClause
{
TableReferences =
{
new NamedTableReference()
{
SchemaObject = CreateCompletedBatchesName()
}
}
},
WhereClause = new WhereClause
{
SearchCondition = new BooleanComparisonExpression
{
ComparisonType = BooleanComparisonType.Equals,
FirstExpression = new ColumnReferenceExpression
{
MultiPartIdentifier = new MultiPartIdentifier
{
Identifiers = { CreateIdentifier(BatchIdColumnName, QuoteType.SquareBracket) }
}
},
SecondExpression = new IntegerLiteral {
Value = batchId.ToString()
}
}
}
};
// Put together the rest of the statement
IfStatement ifNotExists = new IfStatement
{
Predicate = new BooleanNotExpression
{
Expression = existsExp
}
};
return(ifNotExists);
}
public void MatchesPredicate_Constructor_SetsJsonPathSelector()
{
var expectedJsonPathSelector = new JsonPathSelector("$..title");
var fields = new TestPredicateFields();
var predicate = new ExistsPredicate <TestPredicateFields>(fields, jsonpath: expectedJsonPathSelector);
Assert.AreEqual(expectedJsonPathSelector, predicate.JsonPathSelector);
}
public void MatchesPredicate_Constructor_SetsExceptExpression()
{
const string expectedExceptRegex = "!$";
var fields = new TestPredicateFields();
var predicate = new ExistsPredicate <TestPredicateFields>(fields, exceptExpression: expectedExceptRegex);
Assert.AreEqual(expectedExceptRegex, predicate.ExceptExpression);
}
public void MatchesPredicate_Constructor_SetsXpathSelector()
{
var expectedXPathSelector = new XPathSelector("!$");
var fields = new TestPredicateFields();
var predicate = new ExistsPredicate <TestPredicateFields>(fields, xpath: expectedXPathSelector);
Assert.AreEqual(expectedXPathSelector, predicate.XPathSelector);
}
public override void Visit(ExistsPredicate exists)
{
var querySpecification = exists?.Subquery?.QueryExpression as QuerySpecification;
if (querySpecification != null)
{
ProcessTableReferences(querySpecification?.FromClause?.TableReferences, SqlAction.Select);
}
}
public void GetSqlShouldThrowsExceptionIfMapperIsNull()
{
var predicate = new ExistsPredicate <TestEntity>();
var dictionary = new Dictionary <string, object>();
var sqlGenerator = new Mock <ISqlGenerator>();
sqlGenerator.SetupGet(x => x.Configuration)
.Returns(new Mock <IDapperExtensionsConfiguration>().Object);
Assert.Throws <InvalidOperationException>(() =>
{
var sql = predicate.GetSql(sqlGenerator.Object, dictionary);
});
}
public void GetSql()
{
var predicate = new ExistsPredicate <TestEntity>()
{
Predicate = new FieldPredicate <TestEntity>()
{
PropertyName = "Id",
Value = 2,
Operator = Operator.Eq,
}
};
var dictionary = new Dictionary <string, object>();
var sql = predicate.GetSql(SqlHelper.GetSqlGenerator(), dictionary);
Assert.Equal("(EXISTS (SELECT 1 FROM \"TestEntity\" WHERE (Id = @Id_0)))", sql);
Assert.Equal(2, dictionary["@Id_0"]);
}
public void ExistsPredicate_ReturnsProperSql()
{
var pred = new ExistsPredicate <PredicateTestEntity2>
{
Predicate = new PropertyPredicate <PredicateTestEntity, PredicateTestEntity2>
{
PropertyName = "Id",
PropertyName2 = "Key",
Not = false,
Operator = Operator.Eq
}
};
Dictionary <string, object> parameters = new Dictionary <string, object>();
string result = pred.GetSql(parameters);
Assert.AreEqual(
"(EXISTS (SELECT 1 FROM [PredicateTestEntity2] WHERE ([PredicateTestEntity].[Id] = [PredicateTestEntity2].[Key])))",
result);
Assert.AreEqual(0, parameters.Count);
}
public void ExistsPredicateWithNot_ReturnsProperSql()
{
var pred = new ExistsPredicate<PredicateTestEntity2>
{
Not = true,
Predicate = new PropertyPredicate<PredicateTestEntity, PredicateTestEntity2>
{
PropertyName = "Id",
PropertyName2 = "Key",
Not = false,
Operator = Operator.Eq
}
};
Dictionary<string, object> parameters = new Dictionary<string, object>();
string result = pred.GetSql(parameters);
Assert.AreEqual(
"(NOT EXISTS (SELECT 1 FROM [PredicateTestEntity2] WHERE ([PredicateTestEntity].[Id] = [PredicateTestEntity2].[Key])))",
result);
Assert.AreEqual(0, parameters.Count);
}
public override void Visit(ExistsPredicate node) { this.action(node); }
public override void ExplicitVisit(ExistsPredicate node)
{
_buffer.Append("exists (");
node.Subquery.Accept(this);
_buffer.Append(")");
}
void IVisitor.VisitAfter(ExistsPredicate predicate)
{
this.ParentExists(predicate);
}
public void ProcessExistsPredicate(ExistsPredicate ExistsPredicate)
{
_smells.ProcessTsqlFragment(ExistsPredicate.Subquery);
}
public void Visit(ExistsPredicate predicate)
{
_Query.Append("EXISTS ( ");
predicate.SubQuery.Accept(this);
_Query.Append(") ");
}
public void ExistsPredicate(SqlFragment parent, ExistsPredicate existsPredicate)
{
this.Script.Append("EXISTS(");
this.Script.AppendFragment(existsPredicate.SubQuery.FirstFragment, parent, this);
this.Script.Append(")");
}
public override void ExplicitVisit(ExistsPredicate fragment)
{
_fragments.Add(fragment);
}
void IVisitor.VisitBefore(ExistsPredicate predicate)
{
this.ParentExists(predicate);
}
public override void Visit(ExistsPredicate node)
{
base.Visit(node);
ExistsSubqueries.Add(node);
}
