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 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);
}
public static Table GetTableFromObjectId(SqlObjectIdentifier identifier, Dictionary <string, Table> tables, Dictionary <string, Table> tempTables, bool throwException = true)
{
var tableName = Helper.GetQualifiedName(identifier);
if (tempTables.ContainsKey(tableName))
{
return(tempTables[tableName]);
}
if (tables.ContainsKey(tableName))
{
return(tables[tableName]);
}
var foundTables = tables.Where(t => t.Value.Name == identifier.ObjectName.Value).ToList( );
if (foundTables.Count( ) != 1)
{
if (foundTables.Count == 0 && throwException == false)
{
return(null);
}
throw new SqlInvalidTableNameException(tableName);
}
return(foundTables.First( ).Value);
}
public static TableColumn GetTableColumn(SqlObjectIdentifier objectIdentifier, RawData rawData)
{
Table table;
var tableAlias = objectIdentifier.SchemaName.Value;
var aliasList = rawData.TableAliasList;
if (aliasList.Count == 0)
{
foreach (var row in rawData.RawRowList.First())
{
aliasList.Add(row.Table.FullName, row.Table);
}
}
if (objectIdentifier.SchemaName.Value == null)
{
var tables = aliasList
.Where(t => t.Value.Columns.Any(c => c.Name == objectIdentifier.ObjectName.Value))
.ToList( );
if (tables.Count == 0)
{
throw new SqlInvalidColumnNameException(objectIdentifier.ObjectName.Value);
}
if (tables.Count > 1)
{
throw new SqlUnqualifiedColumnNameException(objectIdentifier.ObjectName.Value);
}
var tableEntry = tables.Single( );
table = tableEntry.Value;
tableAlias = tableEntry.Key;
}
else
{
if (aliasList.ContainsKey(tableAlias))
{
table = aliasList[tableAlias];
}
else
{
var tableEntry = aliasList
.Where(a => a.Key == a.Value.FullName)
.Single(t => t.Value.FullName == tableAlias || t.Value.Name == tableAlias);
table = tableEntry.Value;
tableAlias = tableEntry.Key;
}
}
var column = table.Columns.Single(c => c.Name == objectIdentifier.ObjectName.Value);
return(new TableColumn {
TableName = tableAlias, Column = column
});
}
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);
}
public Table(SqlObjectIdentifier name)
{
Name = name.ObjectName.Value;
SchemaName = name.SchemaName?.Value ?? Helper.DefaultSchemaName;
FullName = Helper.GetQualifiedName(name);
Columns = new List <Column>();
PrimaryKeys = new List <Column>();
PrimaryKeyConstraints = new Dictionary <string, List <Column> >();
ForeignKeyConstraints = new List <ForeignKeyConstraint>();
Rows = new List <ArrayList>();
Options = new Dictionary <OptionEnum, string>
{
[OptionEnum.IdentityInsert] = "off"
};
}
public override void Visit(SqlObjectIdentifier codeObject)
{
_stringBuilder.Append(codeObject.Sql);
}
public override void Visit(SqlObjectIdentifier codeObject)
{
Format(codeObject);
}
public static bool IsGlobalTempTable(SqlObjectIdentifier intoTarget)
{
return(IsGlobalTempTable(intoTarget.ObjectName.Value));
}
public static string GetQualifiedName(SqlObjectIdentifier identifier)
{
return((identifier.SchemaName.Value ?? DefaultSchemaName) + "." + identifier.ObjectName);
}
