public bool IsValid(List <RawTableRow> rawDataRows)
{
var scalarValue = Helper.GetValue(_Expression.InExpression, typeof(int), _RawData, rawDataRows);
var type = scalarValue.GetType( );
var valueList = new List <object>( );
foreach (var child in _Expression.ComparisonValue.Children)
{
if (child is SqlScalarExpression scalarExpression)
{
var compareObject = Helper.GetValue(scalarExpression, type, _RawData, rawDataRows);
valueList.Add(compareObject);
}
else if (child is SqlQueryExpression queryExpression)
{
var database = ((MemoryDbConnection )_RawData.Command.Connection).GetMemoryDatabase( );
var command = new MemoryDbCommand(_RawData.Command.Connection, _RawData.Command.Parameters, _RawData.Command.Variables);
var reader = database.ExecuteSqlReader(queryExpression.Sql, command, CommandBehavior.SingleResult);
while (reader.Read( ))
{
valueList.Add(reader[0]);
}
}
else
{
throw new NotImplementedException($"IN is not implemented for type {child}");
}
}
var isValid = valueList.Any(o => scalarValue.Equals(o)) ^ _InvertResult;
return(isValid);
}
public async Task Prepare_NewConnection_FailConnectionShouldSet()
{
var command = new MemoryDbCommand(null, null, null);
Func <Task> act = async() => { await command.PrepareAsync( ); };
await act.Should().ThrowAsync <InvalidOperationException>()
.WithMessage("The Connection should be set.");
}
public static MemoryDbParameter GetParameter(MemoryDbCommand command, SqlScalarExpression scalarExpression)
{
switch (scalarExpression)
{
case SqlScalarVariableRefExpression variableRef:
{
var parameterName = variableRef.VariableName.TrimStart(new [] { '@' });
if (command.Parameters.Contains(parameterName))
{
return(( MemoryDbParameter )command.Parameters[parameterName]);
}
if (command.Variables.Contains(variableRef.VariableName))
{
return(( MemoryDbParameter )command.Variables[variableRef.VariableName]);
}
throw new SqlInvalidVariableException(variableRef.VariableName);
}
}
throw new NotImplementedException();
}
private MemoryDbDataReader.ResultBatchWithRawRows ExecuteSelect(SqlSelectStatement selectExpression,
List <RawTableRow> rows)
{
var querySpecification = ( SqlQuerySpecification )selectExpression.SelectSpecification.QueryExpression;
var db = (( MemoryDbConnection )_RawData.Command.Connection).GetMemoryDatabase( );
var command = new MemoryDbCommand(_RawData.Command.Connection);
var batch = new MemoryDbDataReader.ResultBatchWithRawRows( );
var rawData = new RawData(command, batch)
{
RawRowList = _RawData.RawRowList,
TableAliasList = _RawData.TableAliasList,
SortOrder = selectExpression.SelectSpecification.OrderByClause.Items
};
var statement = new ExecuteQueryStatement(db, command);
statement.InitializeFields(batch, querySpecification.SelectClause.Children.ToList( ), rawData);
if (string.IsNullOrWhiteSpace(_PartitionField) == false)
{
AddWhereParameter(batch, rawData, rows, querySpecification.WhereClause);
}
new QueryResultBuilder(rawData).AddData(batch);
return(batch);
}
public SelectDataFromVariables(SqlScalarExpression scalarExpression, MemoryDbCommand command)
{
Expression = scalarExpression;
_Parameter = Helper.GetParameter(command, scalarExpression);
}
public static object GetValue(SqlScalarExpression expression, Type type, RawData rawData, List <RawTableRow> row, bool getTypeFromLiteral = false)
{
switch (expression)
{
case SqlColumnRefExpression columnRef:
{
var field = GetTableColumn(columnRef, rawData);
var select = new SelectDataFromColumn(field, rawData);
return(GetReturnValue(select, row));
}
case SqlUnaryScalarExpression unaryScalarExpression:
{
var value = GetValue(unaryScalarExpression.Expression, type, rawData, row);
if (unaryScalarExpression.Operator == SqlUnaryScalarOperatorType.Negative)
{
value = HelperReflection.Negate(value);
}
return(value);
}
case SqlLiteralExpression literal:
{
if (literal.Type == LiteralValueType.Null)
{
return(null);
}
var literalType = getTypeFromLiteral ? GetTypeFromLiteralType(literal.Type) : type;
return(GetValueFromString(literalType, literal));
}
case SqlScalarVariableRefExpression variableRef:
{
return(GetValueFromParameter(variableRef.VariableName, rawData.Parameters, rawData.Command.Variables));
}
case SqlScalarRefExpression scalarRef:
{
var field = GetTableColumn((SqlObjectIdentifier)scalarRef.MultipartIdentifier, rawData);
var select = new SelectDataFromColumn(field, rawData);
return(GetReturnValue(select, row));
}
case SqlGlobalScalarVariableRefExpression globalRef:
{
var select = new SelectDataFromGlobalVariables(globalRef.VariableName, rawData);
return(GetReturnValue(select, row));
}
case SqlBuiltinScalarFunctionCallExpression functionCall:
{
var select = new SelectDataBuilder( ).Build(functionCall, rawData);
return(GetReturnValue(select, row));
}
case SqlSearchedCaseExpression caseExpression:
{
var select = new SelectDataFromCaseExpression(caseExpression, rawData);
return(GetReturnValue(select, row));
}
case SqlScalarSubQueryExpression subQuery:
{
var database = new MemoryDbConnection().GetMemoryDatabase( );
var command = new MemoryDbCommand(rawData.Command.Connection, rawData.Command.Parameters, rawData.Command.Variables);
return(database.ExecuteSqlScalar(subQuery.QueryExpression.Sql, command));
}
case SqlBinaryScalarExpression binaryScalarExpression:
{
var select = new SelectDataFromBinaryScalarExpression(binaryScalarExpression, rawData);
return(GetReturnValue(select, row));
}
default:
throw new NotImplementedException($"Unsupported scalarExpression : '{ expression.GetType( ) }'");
}
}
public EvaluateBooleanExpression(RawData rawData, MemoryDatabase database, MemoryDbCommand command)
{
_RawData = rawData;
_Database = database;
_Command = command;
}
