public object Select(RawTableJoinRow rows)
{
if (rows == null)
{
return(null);
}
var tableRow = rows.SingleOrDefault(r => r.Name == TableColumn.TableName);
if (tableRow == null)
{
return(null);
}
object value;
if (TableColumn.Column.ComputedExpression != null)
{
var select = new SelectDataBuilder( ).Build(TableColumn.Column.ComputedExpression, _RawData);
value = select.Select(rows);
if (value.GetType( ) != TableColumn.Column.NetDataType)
{
value = Convert.ChangeType(value, TableColumn.Column.NetDataType);
}
}
else
{
value = tableRow.Row[TableColumn.Column.Order];
}
// pad string if we have a string of a fixed length
if (TableColumn.Column.NetDataType == typeof(string) && TableColumn.Column.IsFixedSize)
{
value = value.ToString( ).PadRight(TableColumn.Column.Size);
}
return(value);
}
public object Select(RawTableJoinRow rows)
{
var selectExpression = ParseAsSelect(_FunctionCall.Sql);
var querySpecification = (SqlQuerySpecification)selectExpression.SelectSpecification.QueryExpression;
var db = (( MemoryDbConnection )_RawData.Command.Connection).GetMemoryDatabase( );
var batch = new MemoryDbDataReader.ResultBatch( );
var rawData = new RawData(_RawData.Command, batch);
rawData.RawRowList.Add(rows);
var statement = new ExecuteQueryStatement(db, _RawData.Command);
statement.InitializeFields(batch, querySpecification.SelectClause.Children.ToList( ), rawData);
new QueryResultBuilder(rawData, false).AddData(batch);
var row = batch.ResultRows[0];
for (int fieldIndex = 0; fieldIndex < batch.Fields.Count; fieldIndex++)
{
if (row[fieldIndex] != null && row[fieldIndex] is DBNull == false)
{
_DbType = (DbType)Enum.Parse(typeof(DbType), batch.Fields[fieldIndex].DbType, true);
_ReturnType = batch.Fields[fieldIndex].NetType;
return(row[fieldIndex]);
}
}
return(null);
}
public object Select(RawTableJoinRow rows)
{
if (_DbType == DbType.String)
{
return(SelectString(rows));
}
if (_DbType == DbType.Byte)
{
return(SelectByte(rows));
}
if (_DbType == DbType.Int16)
{
return(SelectInteger16(rows));
}
if (_DbType == DbType.Int32)
{
return(SelectInteger32(rows));
}
if (_DbType == DbType.Int64)
{
return(SelectInteger(rows));
}
return(SelectDecimal(rows));
}
public object Select(RawTableJoinRow rows)
{
var value = Helper.GetValue(_FunctionCall.Arguments.First( ), typeof(double), _RawData, rows);
if (value == null)
{
return(null);
}
switch (_FunctionCall.FunctionName.ToUpper())
{
case "CEILING":
return(InvokeMathMethod("Ceiling", value));
case "FLOOR":
return(InvokeMathMethod("Floor", value));
case "ABS":
return(InvokeMathMethod("Abs", value));
case "SIGN":
return(InvokeMathMethod("Sign", value));
case "ROUND":
return(InvokeRound(value, rows));
default:
throw new NotImplementedException();
}
}
public object Select(RawTableJoinRow rows)
{
if (_FunctionCall.Arguments != null && _FunctionCall.Arguments.Any())
{
var seed = Helper.GetValue(_FunctionCall.Arguments.First( ), typeof(int), _RawData, rows);
return(new Random((int)seed).NextDouble( ));
}
return(new Random().NextDouble( ));
}
private object CreateGroupByKey(RawTableJoinRow row, List <TableColumn> groupByFields)
{
var keys = new List <string>( );
foreach (var field in groupByFields)
{
keys.Add(new SelectDataFromColumn(field, _RawData).Select(row)?.ToString( ) ?? "<NULL>");
}
return(string.Join("|", keys));
}
public object Select(RawTableJoinRow rows)
{
switch (_FunctionCall.FunctionName.ToUpper())
{
case "NEWID":
return(Guid.NewGuid());
default:
throw new NotImplementedException();
}
}
public object Select(RawTableJoinRow rows)
{
switch (_GlobalVariableName.ToUpper( ))
{
case "@@IDENTITY": return(((MemoryDbConnection )_RawData.Command.Connection).GetMemoryDatabase( ).LastIdentitySet);
case "@@VERSION": return(((MemoryDbConnection )_RawData.Command.Connection).ServerVersion);
default:
throw new NotImplementedException( );
}
}
public object Select(RawTableJoinRow rows)
{
var evaluator = new EvaluateBooleanExpression(_RawData, ((MemoryDbConnection )_RawData.Command.Connection).GetMemoryDatabase( ), _RawData.Command);
foreach (var whenClause in _Expression.WhenClauses)
{
if (evaluator.Evaluate(rows, whenClause.WhenExpression))
{
return(Helper.GetValue(whenClause.ThenExpression, ReturnType, _RawData, rows));
}
}
return(Helper.GetValue(_Expression.ElseExpression, ReturnType, _RawData, rows));
}
public object Select(RawTableJoinRow rows)
{
var arguments = GetArgumentList( );
switch (_FunctionCall.FunctionName.ToUpper())
{
case "ASCII": return(string.IsNullOrWhiteSpace(arguments[0]) ? null : (byte?)arguments[0][0]);
case "CHAR": return(string.IsNullOrWhiteSpace(arguments[0]) ? null : (char?)int.Parse(arguments[0]));
case "CHARINDEX": return(FunctionCharIndex(arguments));
case "CONCAT": return(string.Join("", arguments));
case "DATALENGTH": return(arguments[0]?.Length);
case "LEFT": return(arguments[0]?.Substring(0, Math.Min(arguments[0].Length, int.Parse(arguments[1]))));
case "LEN": return(arguments[0]?.TrimEnd().Length);
case "LOWER": return(arguments[0]?.ToLower());
case "LTRIM": return(arguments[0]?.TrimStart( ));
case "NCHAR": return(string.IsNullOrWhiteSpace(arguments[0]) ? null : (char?)int.Parse(arguments[0]));
case "PATINDEX": return(FunctionPatIndex(arguments));
case "REPLACE": return(new Regex(arguments[1], RegexOptions.IgnoreCase).Replace(arguments[0], arguments[2]));
case "RIGHT": return(arguments[0]?.Substring(Math.Max(0, arguments[0].Length - int.Parse(arguments[1]))));
case "RTRIM": return(arguments[0]?.TrimEnd( ));
case "SPACE": return("".PadRight(int.Parse(arguments[0])));
case "STR": return(FunctionStr(arguments));
case "STUFF": return(FunctionStuff(arguments));
case "SUBSTRING": return(arguments[0]?.Substring(int.Parse(arguments[1]) - 1, int.Parse(arguments[2])));
case "UPPER": return(arguments[0]?.ToUpper());
default:
throw new NotImplementedException();
}
}
public object Select(RawTableJoinRow rows)
{
switch (_FunctionCall.FunctionName.ToUpper( ))
{
case "CURRENT_USER":
case "SESSION_USER":
case "USER_NAME":
return("dbo");
case "SYSTEM_USER":
return(Environment.UserName ?? "Unknown");
default:
throw new NotImplementedException();
}
}
public object Select(RawTableJoinRow rows)
{
switch (_FunctionCall.FunctionName.ToUpper( ))
{
case "CAST":
case "TRY_CAST":
try
{
return(FunctionCast(rows));
}
catch (Exception)
{
if (_FunctionCall.FunctionName.ToUpper( ) == "TRY_CAST")
{
return(null);
}
throw new SqlInvalidCastException(_DbType.ToString());
}
case "CONVERT":
case "TRY_CONVERT":
try
{
return(FunctionConvert(rows));
}
catch (Exception)
{
if (_FunctionCall.FunctionName.ToUpper( ) == "TRY_CONVERT")
{
return(null);
}
throw new SqlInvalidCastException(_DbType.ToString());
}
case "ISDATE":
return(FunctionIsDate(rows));
case "ISNULL":
return(FunctionIsNull(rows));
case "ISNUMERIC":
return(FunctionIsNumeric(rows));
default:
throw new NotImplementedException();
}
}
public object Select(RawTableJoinRow rows)
{
switch (_FunctionCall.FunctionName.ToUpper( ))
{
case "DATEADD": return(FunctionDateAdd(rows));
case "DATEDIFF": return(FunctionDateDiff(rows));
case "DATENAME": return(FunctionDateName(rows));
case "DATEPART": return(FunctionDatePart(rows));
case "SYSDATETIMEOFFSET":
case "SYSDATETIME":
case "GETDATE":
case "CURRENT_TIMESTAMP":
return(DateTime.Now);
case "SYSUTCDATETIME":
case "GETUTCDATE":
return(DateTime.UtcNow);
case "DAY":
var dateDay = (DateTime?)Helper.GetValue(_FunctionCall.Arguments[0], typeof(DateTime), _RawData, rows);
return(dateDay?.Day);
case "MONTH":
var dateMonth = (DateTime?)Helper.GetValue(_FunctionCall.Arguments[0], typeof(DateTime), _RawData, rows);
return(dateMonth?.Month);
case "YEAR":
var dateYear = (DateTime?)Helper.GetValue(_FunctionCall.Arguments[0], typeof(DateTime), _RawData, rows);
return(dateYear?.Year);
default:
throw new NotImplementedException();
}
}
public object Select(RawTableJoinRow rows)
{
var leap = ( int )Helper.GetValue(_FunctionCall.Arguments[1], typeof(int), _RawData, rows);
if (_FunctionCall.FunctionName.ToUpper() == "LAG")
{
leap = 0 - leap;
}
var batch = ExecuteSelect(_SelectExpression, rows);
var index = batch.RawRows.IndexOf(rows);
if (index + leap >= 0 && index + leap < batch.RawRows.Count)
{
return(batch.ResultRows[index + leap][0]);
}
if (_FunctionCall.Arguments.Count > 2)
{
return(Helper.GetValue(_FunctionCall.Arguments[2], _ReturnType, _RawData, rows));
}
return(null);
}
public object Select(RawTableJoinRow rows)
{
if (_FunctionCall.FunctionName.ToUpper() == "SCOPE_IDENTITY")
{
return(((MemoryDbConnection )_RawData.Command.Connection).GetMemoryDatabase( ).LastIdentitySet);
}
if (_FunctionCall.FunctionName.ToUpper() == "IDENT_CURRENT")
{
var database = ((MemoryDbConnection )_RawData.Command.Connection).GetMemoryDatabase( );
var tableName = ((SqlLiteralExpression)_FunctionCall.Arguments.First( )).Value;
if (database.Tables.ContainsKey(tableName))
{
return(database.Tables[tableName].LastIdentitySet);
}
var tables = database.Tables.Where(t => t.Value.Name == tableName).ToList( );
if (tables.Count == 1)
{
return(tables.First( ).Value.LastIdentitySet);
}
throw new SqlInvalidTableNameException(tableName);
}
throw new NotImplementedException( );
}
public object Select(RawTableJoinRow rows)
{
return(_Value);
}
public object Select(RawTableJoinRow rows)
{
throw new NotImplementedException( );
}
public object Select(RawTableJoinRow rows)
{
return(_Parameter.Value);
}
