private Table CreateTable(string name, SqlObjectIdentifier identifier, MemoryDbDataReader.ResultBatch batch,
SqlIdentifierCollection columnList)
{
if (columnList != null)
{
if (columnList.Count > batch.Fields.Count)
{
throw new SqlInsertTooManyColumnsException( );
}
if (columnList.Count < batch.Fields.Count)
{
throw new SqlInsertTooManyValuesException( );
}
}
var table = (identifier != null) ? new Table(identifier) : new Table(name);
for (int fieldIndex = 0; fieldIndex < batch.Fields.Count; fieldIndex++)
{
var field = batch.Fields[fieldIndex];
var sqlType = Helper.DbType2SqlType(field.DbType);
var columnName = columnList != null ? columnList[fieldIndex].Value : field.Name;
var select = (field as MemoryDbDataReader.ReaderFieldData)?.SelectFieldData;
var tc = (select as SelectDataFromColumn)?.TableColumn;
var column = tc != null
? new Column(tc.Column, columnName, table.Columns.Count)
: new Column(table, columnName, sqlType, Database.UserDataTypes, table.Columns.Count);
table.Columns.Add(column);
}
return(table);
}
public RawData(MemoryDbCommand command, MemoryDbDataReader.ResultBatch batch = null)
{
Command = command;
Parameters = command.Parameters;
Database = ((MemoryDbConnection)Command.Connection).GetMemoryDatabase( );
Batch = batch;
}
private void InsertIntoTable(SqlSelectIntoClause sqlQueryIntoClause, Dictionary <string, Table> tables,
MemoryDbDataReader.ResultBatch batch)
{
var connection = (( MemoryDbConnection )_Command.Connection);
bool throwExceptionIfNotFound = Helper.IsTempTable(sqlQueryIntoClause.IntoTarget) == false;
Table table = Helper.GetTableFromObjectId(sqlQueryIntoClause.IntoTarget, tables, connection.TempTables, throwExceptionIfNotFound)
?? new CreateTableFromBatch( ).ToDatabase(sqlQueryIntoClause.IntoTarget, connection, batch);
table.Rows.AddRange(batch.ResultRows);
_Command.RowsAffected += batch.ResultRows.Count;
}
private static void AddFieldFromSelectData(string name, MemoryDbDataReader.ResultBatch batch, ISelectData select)
{
var readerField = new MemoryDbDataReader.ReaderFieldData
{
Name = name,
DbType = select.DbType.ToString(),
NetType = select.ReturnType,
FieldIndex = batch.Fields.Count,
SelectFieldData = select
};
batch.Fields.Add(readerField);
}
private void AddFieldFromColumn(Column column, string tableName, MemoryDbDataReader.ResultBatch batch, RawData rawData)
{
var readerField = new MemoryDbDataReader.ReaderFieldData
{
Name = column.Name,
DbType = column.DbDataType.ToString(),
NetType = column.NetDataType,
FieldIndex = batch.Fields.Count,
SelectFieldData = new SelectDataFromColumn(new TableColumn {
Column = column, TableName = tableName
}, rawData)
};
batch.Fields.Add(readerField);
}
private MemoryDbDataReader.ResultBatch MergeBatches(MemoryDbDataReader.ResultBatch batchLeft,
MemoryDbDataReader.ResultBatch batchRight,
SqlBinaryQueryOperatorType @operator)
{
if (batchLeft.Fields.Count != batchRight.Fields.Count)
{
throw new SqlUnionExpressionCount( );
}
for (int fieldIndex = 0; fieldIndex < batchLeft.Fields.Count; fieldIndex++)
{
if (batchLeft.Fields[fieldIndex].NetType != batchRight.Fields[fieldIndex].NetType)
{
throw new SqlConversionException(batchLeft.Fields[fieldIndex].DbType, batchRight.Fields[fieldIndex].DbType);
}
}
var batch = new MemoryDbDataReader.ResultBatch {
Fields = batchLeft.Fields
};
switch (@operator)
{
case SqlBinaryQueryOperatorType.UnionAll:
batch.ResultRows.AddRange(batchLeft.ResultRows);
batch.ResultRows.AddRange(batchRight.ResultRows);
break;
case SqlBinaryQueryOperatorType.Union:
batch.ResultRows.AddRange(batchRight.ResultRows);
batch.ResultRows.AddRange(batchLeft.ResultRows.Where(r => batchRight.ResultRows.Any(rr => RawData.RowsAreEqual(rr, r) == false)));
break;
case SqlBinaryQueryOperatorType.Intersect:
batch.ResultRows.AddRange(batchLeft.ResultRows.Where(r => batchRight.ResultRows.Any(rr => RawData.RowsAreEqual(rr, r))));
break;
case SqlBinaryQueryOperatorType.Except:
batch.ResultRows.AddRange(batchLeft.ResultRows.Where(r => batchRight.ResultRows.Any(rr => RawData.RowsAreEqual(rr, r)) == false));
break;
default:
throw new NotImplementedException($"not implemented for type: {@operator}");
}
return(batch);
}
private void InitializeField(MemoryDbDataReader.ResultBatch batch, RawData rawData, SqlScalarExpression scalarExpression, string name)
{
switch (scalarExpression)
{
case SqlGlobalScalarVariableRefExpression globalRef:
AddFieldFromGlobalVariable(globalRef, name, batch, rawData);
break;
case SqlScalarVariableRefExpression variableRef:
AddFieldFromVariable(variableRef, name, batch, rawData);
break;
case SqlScalarRefExpression scalarRef:
AddFieldFromColumn(( SqlObjectIdentifier )scalarRef.MultipartIdentifier, name, batch, rawData);
break;
case SqlLiteralExpression literalExpression:
AddFieldFromLiteral(literalExpression, name, batch, rawData);
break;
case SqlBuiltinScalarFunctionCallExpression functionCall:
AddFieldForFunctionCall(functionCall, name, batch, rawData);
break;
case SqlNullScalarExpression nullScalarExpression:
AddFieldForNullScalarExpression(nullScalarExpression, name, batch, rawData);
break;
case SqlSearchedCaseExpression caseExpression:
AddFieldFromCaseExpression(caseExpression, name, batch, rawData);
break;
case SqlBinaryScalarExpression binaryExpression:
AddFieldFromBinaryExpression(binaryExpression, name, batch, rawData);
break;
case SqlUnaryScalarExpression unaryScalarExpression:
InitializeField(batch, rawData, unaryScalarExpression.Expression, name);
break;
default:
throw new NotImplementedException(
$"Currently expression of type {scalarExpression.GetType( )} is not implemented");
}
}
public void InitializeFields(MemoryDbDataReader.ResultBatch batch, List <SqlCodeObject> columns, RawData rawData)
{
foreach (var column in columns)
{
if (column is SqlSelectScalarExpression scalarExpression)
{
var name = Helper.GetColumnAlias(scalarExpression);
InitializeField(batch, rawData, scalarExpression.Expression, name);
}
else if (column is SqlTopSpecification topSpecification)
{
if (topSpecification.Value.Sql.All(char.IsDigit))
{
batch.MaxRowsCount = int.Parse(topSpecification.Value.Sql);
}
else if (topSpecification.Value is SqlScalarVariableRefExpression variableRef)
{
batch.MaxRowsCount = (int?)Helper.GetValueFromParameter(variableRef.VariableName, rawData.Parameters, rawData.Command.Variables);
}
else
{
throw new NotImplementedException($"top specification of type { topSpecification.Value.GetType()} is not implemented");
}
}
else if (column is SqlSelectStarExpression selectStarExpression)
{
foreach (var tableAlias in rawData.TableAliasList)
{
foreach (var valueColumn in tableAlias.Value.Columns)
{
AddFieldFromColumn(valueColumn, tableAlias.Key, batch, rawData);
}
}
}
else
{
throw new NotImplementedException($"Not implemented column specification {column}");
}
}
}
private MemoryDbDataReader.ResultBatch InitializeBatch(RawData rawData, SqlQuerySpecification sqlQuery)
{
var batch = new MemoryDbDataReader.ResultBatch( );
var fields = sqlQuery.SelectClause.Children.ToList( );
if (_InsertColumns != null)
{
var fieldCount = fields.Count;
if (_InsertColumns.Count > fieldCount)
{
throw new SqlInsertTooManyColumnsException( );
}
if (_InsertColumns.Count < fieldCount)
{
throw new SqlInsertTooManyValuesException( );
}
}
InitializeFields(batch, fields, rawData);
return(batch);
}
private List <RawTableJoinRow> ResultBatch2RowList(Table table,
MemoryDbDataReader.ResultBatch batch, SqlIdentifierCollection columnList = null)
{
var rowList = new List <RawTableJoinRow>( );
foreach (var row in batch.ResultRows)
{
var tableRow = new RawTableRow
{
Name = table.FullName,
Table = table,
Row = row
};
var rows = new RawTableJoinRow( )
{
tableRow
};
rowList.Add(rows);
}
return(rowList);
}
private void AddFieldFromBinaryExpression(SqlBinaryScalarExpression expression, string name, MemoryDbDataReader.ResultBatch batch, RawData rawData)
{
var select = new SelectDataFromBinaryScalarExpression(expression, rawData);
AddFieldFromSelectData(name, batch, select);
}
private void AddFieldFromCaseExpression(SqlSearchedCaseExpression caseExpression, string name, MemoryDbDataReader.ResultBatch batch, RawData rawData)
{
var select = new SelectDataFromCaseExpression(caseExpression, rawData);
AddFieldFromSelectData(name, batch, select);
}
private void AddFieldForFunctionCall(SqlBuiltinScalarFunctionCallExpression functionCall, string name, MemoryDbDataReader.ResultBatch batch, RawData rawData)
{
var select = new SelectDataBuilder( ).Build(functionCall, rawData);
AddFieldFromSelectData(name, batch, select);
}
private void AddFieldFromLiteral(SqlLiteralExpression literalExpression, string name, MemoryDbDataReader.ResultBatch batch, RawData rawData)
{
if (_InsertColumns != null)
{
var column = _InsertColumns[batch.Fields.Count];
var value = Helper.GetValueFromString(column.NetDataType, literalExpression);
var readerField = new MemoryDbDataReader.ReaderFieldData
{
Name = column.Name,
DbType = column.DbDataType.ToString(),
NetType = column.NetDataType,
FieldIndex = batch.Fields.Count
};
readerField.SelectFieldData = new SelectDataFromObject(value, readerField.DbType);
batch.Fields.Add(readerField);
}
else
{
if (literalExpression.Type == LiteralValueType.Null)
{
var nullField = Helper.BuildFieldFromNullValue(name, batch.Fields.Count);
batch.Fields.Add(nullField);
return;
}
var readerField = Helper.BuildFieldFromLiteral(literalExpression.Type, name, batch.Fields.Count);
var value = Helper.GetValueFromString(readerField.NetType, literalExpression);
readerField.SelectFieldData = new SelectDataFromObject(value, readerField.DbType);
batch.Fields.Add(readerField);
}
}
private void AddFieldFromVariable(SqlScalarVariableRefExpression variableRef, string name, MemoryDbDataReader.ResultBatch batch, RawData rawData)
{
var select = new SelectDataFromVariables(variableRef, _Command);
AddFieldFromSelectData(name, batch, select);
}
private void AddFieldFromGlobalVariable(SqlGlobalScalarVariableRefExpression globalRef, string name, MemoryDbDataReader.ResultBatch batch, RawData rawData)
{
var select = new SelectDataBuilder( ).BuildGlobalVariable(globalRef.VariableName, rawData);
AddFieldFromSelectData(name, batch, select);
}
public Table ToDatabase(SqlObjectIdentifier identifier, MemoryDbConnection connection, MemoryDbDataReader.ResultBatch batch)
{
var table = new Table(identifier);
foreach (var field in batch.Fields)
{
Column column;
if ((field as MemoryDbDataReader.ReaderFieldData)?.SelectFieldData is SelectDataFromColumn select)
{
column = new Column(select.TableColumn.Column, field.Name, table.Columns.Count)
{
ParentTable = table,
ComputedExpression = null
};
}
else
{
var sqlType = Helper.DbType2SqlType(field.DbType);
column = new Column(table, field.Name, sqlType, connection.GetMemoryDatabase( ).UserDataTypes, table.Columns.Count);
}
table.Columns.Add(column);
}
if (Helper.IsLocalTempTable(identifier))
{
connection.TempTables.Add(table.FullName, table);
}
else
{
connection.MemoryDatabase.Tables.Add(table.FullName, table);
}
return(table);
}
private void AddFieldFromColumn(SqlObjectIdentifier objectIdentifier, string name, MemoryDbDataReader.ResultBatch batch, RawData rawData)
{
var tableColumn = Helper.GetTableColumn(objectIdentifier, rawData);
var readerField = new MemoryDbDataReader.ReaderFieldData
{
Name = name,
DbType = tableColumn.Column.DbDataType.ToString(),
NetType = tableColumn.Column.NetDataType,
FieldIndex = batch.Fields.Count,
SelectFieldData = new SelectDataFromColumn(tableColumn, rawData)
};
batch.Fields.Add(readerField);
}
