private SourceCode GetConstructors(SemanticModel semanticModel, HashSet <string> typeReferences, IEnumerable <ConstructorDeclarationSyntax> constructorDeclarations)
{
var generatedConstructors = new SourceCode {
MainPart = ""
};
foreach (var constructorDeclaration in constructorDeclarations)
{
string identifier = constructorDeclaration.Identifier.ValueText;
var parameters = new List <Var>();
foreach (var parameter in constructorDeclaration.ParameterList.Parameters)
{
var typeReference = TypeReferenceGenerator.GenerateTypeReference(parameter.Type, semanticModel);
parameters.Add(new Var
{
Name = parameter.Identifier.ValueText,
Type = typeReference
});
}
var constructorAccessModifier = GetAccessModifier(constructorDeclaration.Modifiers.ToList());
var statements = new List <string>();
foreach (var statement in constructorDeclaration.Body.Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
}
var generatedConstructor = ConstructorGenerator.Generate(identifier, constructorAccessModifier, parameters,
statements, semanticModel);
generatedConstructors.MainPart += "\n" + generatedConstructor.MainPart;
}
return(generatedConstructors);
}
public void CreateOrReplaceTable()
{
//Arrange
var creationMetadata = GetEntityCreationMetadata(topicName: "my_movie");
//Act
string statement = StatementGenerator.CreateOrReplaceTable <CreateEntityTests.MyMovie>(creationMetadata);
//Assert
statement.Should().Be($"CREATE OR REPLACE TABLE{GetExpectedClauses(isTable: true)}");
}
public void CreateStream()
{
//Arrange
var creationMetadata = GetEntityCreationMetadata(topicName: "my_movie");
//Act
string statement = StatementGenerator.CreateStream <CreateEntityTests.MyMovie>(creationMetadata);
//Assert
statement.Should().Be($"CREATE STREAM{GetExpectedClauses(isTable: false)}");
}
/// <summary>
/// Create a new table or replace an existing one with the specified columns and properties.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="creationMetadata">Table properties, specify details about your table by using the WITH clause.</param>
/// <param name="cancellationToken">Optional cancellation token to cancel the operation</param>
/// <returns>Http response object.</returns>
public Task <HttpResponseMessage> CreateOrReplaceTableAsync <T>(EntityCreationMetadata creationMetadata, CancellationToken cancellationToken = default)
{
if (creationMetadata == null)
{
throw new ArgumentNullException(nameof(creationMetadata));
}
var ksql = StatementGenerator.CreateOrReplaceTable <T>(creationMetadata);
return(ExecuteAsync <T>(ksql, cancellationToken));
}
public void CreateTable_IfNotExists()
{
//Arrange
var creationMetadata = GetEntityCreationMetadata(topicName: "my_movie");
//Act
string statement = StatementGenerator.CreateTable <CreateEntityTests.MyMovie>(creationMetadata, ifNotExists: true);
//Assert
statement.Should().Be($"CREATE TABLE IF NOT EXISTS{GetExpectedClauses(isTable: true)}");
}
/// <summary>
/// Create a new stream with the specified columns and properties.
/// </summary>
/// <typeparam name="T">The type that represents the stream.</typeparam>
/// <param name="creationMetadata">Stream properties, specify details about your stream by using the WITH clause.</param>
/// <param name="ifNotExists">If the IF NOT EXISTS clause is present, the statement won't fail if a stream with the same name already exists.</param>
/// <param name="cancellationToken">Optional cancellation token to cancel the operation</param>
/// <returns>Http response object.</returns>
public Task <HttpResponseMessage> CreateStreamAsync <T>(EntityCreationMetadata creationMetadata, bool ifNotExists = false, CancellationToken cancellationToken = default)
{
if (creationMetadata == null)
{
throw new ArgumentNullException(nameof(creationMetadata));
}
var ksql = StatementGenerator.CreateStream <T>(creationMetadata, ifNotExists);
return(ExecuteAsync <T>(ksql, cancellationToken));
}
public void TestInitialize()
{
_generator = new StatementGenerator();
_generator.InjectDependency(_constantGenerator = new ConstantGeneratorStub());
_generator.InjectDependency(_identifierGenerator = new IdentifierGeneratorStub());
_generator.InjectDependency(_assignmentGenerator = new AssignmentGeneratorStub());
_generator.InjectDependency(_blockGenerator = new BlockGeneratorStub());
_generator.InjectDependency(_arrayGenerator = new ArrayGeneratorStub());
_generator.InjectDependency(_accessorGenerator = new AccessorGeneratorStub());
_generator.InjectDependency(_methodCallGenerator = new MethodCallGeneratorStub());
_generator.InjectDependency(_returnStatementGenerator = new ReturnStatementGeneratorStub());
_generator.InjectDependency(_newStatementGenerator = new NewStatementGeneratorStub());
}
public void StringProperty()
{
var templateText = @"This is a {{ Length }} World from scriban!";
var template = Template.Parse(templateText, null, null, null);
var result = new StatementGenerator(new NullLogger <StatementGenerator>()).Generate <string, object>(new ExpressContext(), template.Page.Body);
var functor = result.Compile();
var sb = new StringBuilder();
functor(sb, "Hello", null);
Assert.Equal("This is a 5 World from scriban!", sb.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Ceql.Statements.UpdateStatement`1"/> class.
/// </summary>
/// <param name="expressions">Expressions.</param>
public UpdateStatement(params Expression <SelectExpression <T, object> >[] expressions)
{
_formatter = CeqlConfiguration.Instance.GetConnectorFormatter();
_fromClause = new FromClause <T>();
_primaryKeyProperties = typeof(T).GetPrimaryKeyProperties();
_fromAlias = StatementGenerator.GetAliasList(_fromClause);
foreach (var expression in expressions)
{
var selectList = (List <SelectAlias>) new SelectExpressionAnalyzer(_formatter, expression, _fromAlias).Sql();
_selections.AddRange(selectList);
}
}
public void RawTextBlock()
{
var statementGenerator = new StatementGenerator(new NullLogger <StatementGenerator>());
var templateText = @"This is a World from scriban!";
var template = Template.Parse(templateText, null, null, null);
var result = statementGenerator.Generate <string, object>(new ExpressContext(), template.Page.Body);
var functor = result.Compile();
var sb = new StringBuilder();
functor(sb, "doesn'tm atter", null);
Assert.Equal("This is a World from scriban!", sb.ToString());
}
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
SyntaxList <StatementSyntax> blockWithNewStatements = node.Body.Statements;
for (int i = 0; i < RandomUtils.GenerateLittleInt(); i++)
{
blockWithNewStatements = blockWithNewStatements.Insert(0, StatementGenerator.GenerateSingleStatement());
}
BlockSyntax newBlock = SyntaxFactory.Block(blockWithNewStatements);
MethodDeclarationSyntax newMethod2 = node.WithBody(newBlock);
var newNode = node.ReplaceNode(node, newMethod2);
return(base.VisitMethodDeclaration(newNode));
}
/// <summary>
/// Applies update statement values to be set on fields specified in constructor expressions.
/// </summary>
/// <returns>The values.</returns>
/// <param name="values">Values.</param>
public IUpdateStatement <T> Values(params object[] values)
{
_values = values;
// create sql statement
Sql = "UPDATE " + StatementGenerator.TableSql(_fromClause, _fromAlias, _formatter) + " SET ";
var counter = 0;
foreach (var alias in _selections)
{
var value = _formatter.Format(alias, values[counter]);
Sql += alias + " = " + value;
}
return(this);
}
public void CanGenerateBankStatement_ShouldReturnTrue()
{
var bankAccount = new BankAccount();
bankAccount.DepositFunds(5.00);
bankAccount.DepositFunds(10.00);
bankAccount.WithdrawFunds(6.00);
// balance now should be 9.00
var bankStatement = StatementGenerator.GenerateBankStatement(bankAccount);
// first transaction should be most recent
Assert.AreNotEqual(bankStatement, null);
Assert.AreEqual(bankAccount.Balance, 9.00);
Assert.AreEqual(bankStatement.First().TransactionType, "Withdrawal");
Assert.IsTrue(bankStatement.FirstOrDefault().Amount.Equals(6.00));
Assert.IsTrue(bankStatement.FirstOrDefault().TransactionId.Equals(2));
}
private SourceCode GetMethods(SemanticModel semanticModel, HashSet <string> typeReferences, IEnumerable <MethodDeclarationSyntax> methodDeclarations)
{
var generatedMethods = new SourceCode {
MainPart = ""
};
foreach (var methodDeclaration in methodDeclarations)
{
string identifier = methodDeclaration.Identifier.ValueText;
var returnType = methodDeclaration.ReturnType;
var returnTypeReference = TypeReferenceGenerator.GenerateTypeReference(returnType, semanticModel);
if (!returnTypeReference.IsPredefined)
{
typeReferences.Add(returnTypeReference.Text);
}
var typeParameters = new List <string>();
if (methodDeclaration.TypeParameterList != null)
{
foreach (var typeParameter in methodDeclaration.TypeParameterList.Parameters)
{
typeParameters.Add(typeParameter.Identifier.ValueText);
}
}
var parameters = new List <Var>();
foreach (var parameter in methodDeclaration.ParameterList.Parameters)
{
var typeReference = TypeReferenceGenerator.GenerateTypeReference(parameter.Type, semanticModel);
parameters.Add(new Var
{
Name = parameter.Identifier.ValueText,
Type = typeReference
});
}
var accessModifier = GetAccessModifier(methodDeclaration.Modifiers.ToList());
bool isStatic = HasStaticModifier(methodDeclaration.Modifiers.ToList());
Optional <List <string> > body;
if (methodDeclaration.Body == null)
{
body = new Optional <List <string> >();
}
else
{
var statements = new List <string>();
foreach (var statement in methodDeclaration.Body.Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
new Optional <List <string> >();
}
body = new Optional <List <string> >(statements);
}
bool isVirtual = !body.HasValue || HasVirtualModifier(methodDeclaration.Modifiers.ToList());
var generatedMethod = MethodGenerator.Generate(identifier,
returnTypeReference,
typeParameters,
accessModifier,
parameters,
body,
isStatic,
isVirtual,
semanticModel);
generatedMethods.MainPart += "\n" + generatedMethod.MainPart;
}
return(generatedMethods);
}
/// <summary>
/// Where the specified expression.
/// </summary>
/// <returns>The where.</returns>
/// <param name="expression">Expression.</param>
public IUpdateStatement <T> Where(Expression <BooleanExpression <T> > expression)
{
WhereClause = new WhereClause <T>(_fromClause, expression);
Sql += " " + StatementGenerator.WhereSql(WhereClause, _fromAlias, _formatter);
return(this);
}
public StatementGeneratorTests()
{
statementGenerator = Factory.CreateStatementGenerator();
}
private SourceCode GetProperties(SemanticModel semanticModel, HashSet <string> typeReferences,
IEnumerable <PropertyDeclarationSyntax> propertyDeclarations, bool isFromInterface)
{
var generatedProperties = new SourceCode {
MainPart = ""
};
foreach (var propertyDeclaration in propertyDeclarations)
{
string identifier = propertyDeclaration.Identifier.ValueText;
var propertyType = propertyDeclaration.Type;
var typeReference = TypeReferenceGenerator.GenerateTypeReference(propertyType, semanticModel);
if (!typeReference.IsPredefined)
{
typeReferences.Add(typeReference.Text);
}
bool isStatic = HasStaticModifier(propertyDeclaration.Modifiers.ToList());
bool isVirtual = isFromInterface || HasVirtualModifier(propertyDeclaration.Modifiers.ToList());
var propertyAccessModifier = GetAccessModifier(propertyDeclaration.Modifiers.ToList());
var accessors = propertyDeclaration.AccessorList.Accessors;
var getAccessor = accessors.FirstOrDefault(syntax => syntax.Keyword.Text == "get");
var setAccessor = accessors.FirstOrDefault(syntax => syntax.Keyword.Text == "set");
if (propertyDeclaration.AccessorList.Accessors.Any(syntax => syntax.Body != null))
{
var complexPropertyDescription = new ComplexPropertyDescription
{
PropertyName = identifier,
PropertyType = typeReference,
GetAccessModifier = new Optional <AccessModifier>(),
SetAccessModifier = new Optional <AccessModifier>(),
IsStatic = isStatic,
IsVirtual = isVirtual
};
if (getAccessor != null)
{
var getAccessModifier = GetAccessModifier(getAccessor.Modifiers);
var getModifier = MaxRestrictionAccessModifier(propertyAccessModifier, getAccessModifier);
complexPropertyDescription.GetAccessModifier = getModifier;
if (getAccessor.Body != null)
{
var statements = new List <string>();
foreach (var statement in getAccessor.Body.Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
}
complexPropertyDescription.GetStatements = statements;
}
}
if (setAccessor != null)
{
var setAccessModifier = GetAccessModifier(setAccessor.Modifiers);
var setModifier = MaxRestrictionAccessModifier(propertyAccessModifier, setAccessModifier);
complexPropertyDescription.SetAccessModifier = setModifier;
if (setAccessor.Body != null)
{
var statements = new List <string>();
foreach (var statement in setAccessor.Body.Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
}
complexPropertyDescription.SetStatements = statements;
}
}
SourceCode generatedProperty = PropertyGenerator.GenerateComplexProperty(complexPropertyDescription, semanticModel);
generatedProperties.MainPart += "\n" + generatedProperty.MainPart;
}
else
{
var simplePropertyDescription = new SimplePropertyDescription
{
PropertyName = identifier,
PropertyType = typeReference,
GetAccessModifier = new Optional <AccessModifier>(),
SetAccessModifier = new Optional <AccessModifier>(),
IsStatic = isStatic,
IsVirtual = isVirtual,
IsFromInterface = isFromInterface
};
if (getAccessor != null)
{
var getAccessModifier = GetAccessModifier(getAccessor.Modifiers);
var getModifier = MaxRestrictionAccessModifier(propertyAccessModifier, getAccessModifier);
simplePropertyDescription.GetAccessModifier = getModifier;
}
if (setAccessor != null)
{
var setAccessModifier = GetAccessModifier(setAccessor.Modifiers);
var setModifier = MaxRestrictionAccessModifier(propertyAccessModifier, setAccessModifier);
simplePropertyDescription.SetAccessModifier = setModifier;
}
SourceCode generatedProperty = PropertyGenerator
.GenerateSimpleProperty(simplePropertyDescription, semanticModel, isFromInterface);
generatedProperties.MainPart += "\n" + generatedProperty.MainPart;
}
}
return(generatedProperties);
}
