public static ColumnDefinition Column(string columnName,
DataTypeReference dataType,
bool nullable = false,
QuoteType quoteType = QuoteType.NotQuoted)
{
return(Column(Identifier(columnName, quoteType), dataType, nullable));
}
public IEnumerable <ColumnDefinition> GenerateColumnDefinitions(Table table, QuoteType quoteType = QuoteType.NotQuoted)
{
List <ColumnDefinition> columns = new List <ColumnDefinition>();
foreach (var column in table.Columns)
{
SqlDataType sqlDataType = SqlDataType.Parse(column.DataType);
DataTypeReference dataType = GenerateDataTypeReference(sqlDataType);
if (column.IsIdentity)
{
ColumnDefinition columnDef = ScriptFactory.IdentityColumn(column.Name, dataType, CreateIdentityOptions(column), quoteType);
columns.Add(columnDef);
}
else if (column.RowGuid)
{
if (!string.IsNullOrEmpty(column.DefaultValue))
{
ColumnDefinition rowGuidCol = ScriptFactory.ColumnDefinition(column.Name, column.DefaultValue, column.DefaultName, dataType, column.AllowNulls, column.RowGuid, quoteType);
columns.Add(rowGuidCol);
}
}
else
{
columns.Add(ScriptFactory.ColumnDefinition(column.Name, dataType, column.AllowNulls, quoteType));
}
}
return(columns);
}
public static string DataType(DataTypeReference dtype)
{
switch (dtype.GetType().Name)
{
case "SqlDataTypeReference":
{
var sqltype = dtype as SqlDataTypeReference;
var sb = new StringBuilder(1024);
sb.Append(SchemaObjectName(sqltype.Name));
if (sqltype.Parameters.Any())
{
sb.Append("(");
for (var j = 0; j < sqltype.Parameters.Count; ++j)
{
if (j > 0)
{
sb.Append(", ");
}
sb.Append(sqltype.Parameters[j].Value);
}
sb.Append(")");
}
return(sb.ToString());
}
default:
return("");
}
}
public static Field GetField(this DataTypeReference dataTypeReference, string name, bool isNullable, ILogger logger, SchemaFile file)
{
if (dataTypeReference is SqlDataTypeReference sqlDataTypeReference)
{
return(sqlDataTypeReference.GetField(name, isNullable, logger, file));
}
if (dataTypeReference is UserDataTypeReference userDataTypeReference)
{
return(userDataTypeReference.GetField(name, isNullable, logger, file));
}
if (dataTypeReference is XmlDataTypeReference xmlDataTypeReference)
{
return(new DefaultField()
{
Name = name,
Type = FieldType.Xml,
IsNullable = isNullable,
});
}
logger.Log(LogLevel.Warning,
LogType.NotSupportedYet,
file.Path,
$"{dataTypeReference.GetType()} data type reference is not supported yet. " +
$"Fragment: \"{dataTypeReference.GetTokenText()}\"");
return(new UnknownField()
{
Name = name,
});
}
public static FieldType GetFieldType(this DataTypeReference dataTypeReference, ILogger logger, SchemaFile file)
{
if (dataTypeReference is SqlDataTypeReference sqlDataTypeReference)
{
return(sqlDataTypeReference.GetFieldType());
}
if (dataTypeReference is UserDataTypeReference)
{
return(FieldType.UserDataType);
}
if (dataTypeReference is XmlDataTypeReference)
{
return(FieldType.Xml);
}
logger.Log(LogLevel.Warning,
LogType.NotSupportedYet,
file.Path,
$"{dataTypeReference.GetType()} column type is not supported yet. " +
$"Fragment: \"{dataTypeReference.GetTokenText()}\"");
return(FieldType.NotSpecified);
}
public static ColumnDefinition Column(string columnName,
DataTypeReference dataType,
bool nullable = false,
bool isRowGuid = false,
QuoteType quoteType = QuoteType.NotQuoted)
{
return(Column(ScriptFactory.Identifier(columnName, quoteType), dataType, nullable, isRowGuid));
}
public DataTypeView(string name, DataTypeReference dataType, DataTypeViewType type)
{
Name = name;
DataType = dataType.Name.Identifiers.Last().Value;
var length = (dataType as ParameterizedDataTypeReference)?.Parameters.FirstOrDefault()?.Value;
Length = length?.ToLower() == "max" ? -1 : Convert.ToInt32(length);
Type = type;
}
public static ColumnDefinition Column(string columnName,
string defaultValue,
string defaultName,
DataTypeReference dataType,
bool nullable = false,
bool isRowGuid = false,
QuoteType quoteType = QuoteType.NotQuoted)
{
return(Column2(columnName, defaultValue, defaultName, dataType, nullable, isRowGuid, quoteType));
}
public override void ExplicitVisit(DeclareVariableElement node)
{
if (string.Equals(node.VariableName.Value, VariableName, StringComparison.OrdinalIgnoreCase))
{
VariableDataType = node.DataType;
//variableDefinition = node.Definition;
//throw new NotImplementedException(node.WhatIsThis());
}
base.ExplicitVisit(node);
}
public static ColumnDefinition Column(Identifier columnName, DataTypeReference dataType, bool nullable = false, bool isRowGuid = false)
{
var fragment = new ColumnDefinition();
fragment.ColumnIdentifier = columnName;
fragment.DataType = dataType;
fragment.IsRowGuidCol = isRowGuid;
fragment.Constraints.Add(NullableConstraint(nullable));
return(fragment);
}
public static ColumnDefinition IdentityColumn(string columnName,
DataTypeReference dataType,
IdentityOptions options,
QuoteType quoteType = QuoteType.NotQuoted)
{
ColumnDefinition definition = Column(columnName, dataType, false, quoteType);
definition.IdentityOptions = options;
return(definition);
}
/// <summary>
/// Converts a <see cref="DataTypeReference"/> to a <see cref="TypeSyntax"/>
/// </summary>
/// <param name="dataType">The type</param>
/// <param name="nullable">Whether the type is nullable</param>
/// <returns>The <see cref="TypeSyntax"/></returns>
protected static TypeSyntax DataTypeReferenceToClrType(DataTypeReference dataType, bool nullable)
{
if (Enum.TryParse <SqlDbType>(dataType.Name.BaseIdentifier.Value, ignoreCase: true, out var sqlDbType))
{
return(SqlDbTypeToClrType(sqlDbType, nullable).ToTypeSyntax(useGlobalAlias: true));
}
// assumed to be a table type
return(TypeExtensions.CreateGenericTypeFromGenericTypeDefinition(
typeof(IEnumerable <>).ToTypeSyntax(true),
SyntaxFactory.IdentifierName(GetRowStructNameForTableType(dataType.Name))));
}
private static string StringLength(DataTypeReference t)
{
if (!(t is ParameterizedDataTypeReference p))
{
return(null);
}
var v = p.Parameters[0].Value;
if (v == "MAX")
{
return(null);
}
return($"StringLength({v})");
}
private static bool IsDataTypeInvalid(DataTypeReference dataTypeReference)
{
var dataType = dataTypeReference as SqlDataTypeReference;
if (dataType == null)
{
return(false);
}
var invalidDataTypes = new[] { SqlDataTypeOption.Text, SqlDataTypeOption.NText, SqlDataTypeOption.Image };
return(invalidDataTypes.Contains(dataType.SqlDataTypeOption) ||
(dataType.Parameters.Any() && dataType.Parameters.FirstOrDefault(x => x.LiteralType == LiteralType.Max) != null));
}
public static IEnumerable <decimal> GetDataTypeParameters(this DataTypeReference dataType)
{
if (dataType == null)
{
return(Enumerable.Empty <decimal>());
}
if (dataType is ParameterizedDataTypeReference parameterizedDataType)
{
Type type = typeof(decimal);
return(parameterizedDataType.Parameters.Select(l =>
(decimal)Convert.ChangeType((l.Value.StringEquals("MAX") ? "-1" : l.Value), type)
));
}
return(Enumerable.Empty <decimal>());
}
// Factory to create the appropriate subtype
public static SqlTypeInfo Create(DataTypeReference dataType)
{
if (dataType == null)
{
return Unknown;
}
var sqlDataType = dataType as SqlDataTypeReference;
if (sqlDataType == null)
{
// we don't yet handle any other type - treat them as as unknown
return Unknown;
}
return new FullSqlTypeInfo(sqlDataType);
}
public static ColumnDefinition ColumnDefinition(string columnName,
string defaultValue,
string defaultName,
DataTypeReference dataType,
bool nullable = false,
bool isRowGuid = false,
QuoteType quoteType = QuoteType.NotQuoted)
{
var fragment = new ColumnDefinition();
fragment.Constraints.Add(NullableConstraintDefinition(null, nullable));
fragment.Constraints.Add(DefaultConstraintDefinition(
null,
Identifier(defaultName, quoteType),
false,
IdentifierLiteral(defaultValue)));
fragment.ColumnIdentifier = Identifier(columnName, quoteType);
fragment.IsRowGuidCol = isRowGuid;
fragment.DataType = dataType;
return(fragment);
}
public IEnumerable <ColumnDefinition> GenerateColumnDefinitions(Table table, QuoteType quoteType = QuoteType.NotQuoted)
{
List <ColumnDefinition> columns = new List <ColumnDefinition>();
foreach (var column in table.Columns)
{
//Debug.Print($"CURRENT COLUMN IS {column.Name} FROM TABLE {column.Parent.Name}");
SqlDataType sqlDataType = SqlDataType.Parse(column.DataType);
DataTypeReference dataType = GenerateDataTypeReference(sqlDataType);
if (column.IsIdentity)
{
ColumnDefinition columnDef = IdentityColumn(column.Name, dataType, CreateIdentityOptions(column), quoteType);
columns.Add(columnDef);
}
else if (column.RowGuid)
{
if (!string.IsNullOrEmpty(column.DefaultValue))
{
ColumnDefinition rowGuidCol = Column(column.Name, column.DefaultValue, column.DefaultName, dataType, column.AllowNulls, column.RowGuid, quoteType);
//rowGuidCol.DefaultConstraint = ScriptFactory.DefaultConstraintDefinition(
// ScriptFactory.Identifier(column.Name, quoteType),
// ScriptFactory.Identifier(column.DefaultName),
// false,
columns.Add(rowGuidCol);
}
}
else
{
columns.Add(Column(column.Name, dataType, column.AllowNulls, quoteType));
}
}
return(columns);
}
public static List <ColumnDefinition> CreateColumnDefinitions(Table table, QuoteType quoteType = QuoteType.NotQuoted)
{
List <ColumnDefinition> columns = new List <ColumnDefinition>();
foreach (var column in table.Columns)
{
//Debug.Print($"CURRENT COLUMN IS {column.Name} FROM TABLE {column.Parent.Name}");
SqlDataType sqlDataType = SqlDataType.Parse(column.DataType);
DataTypeReference dataType = CreateDataTypeReference(sqlDataType);
if (column.IsIdentity)
{
ColumnDefinition columnDef = Factory.IdentityColumn(column.Name, dataType, CreateIdentityOptions(column), quoteType);
columns.Add(columnDef);
}
else
{
columns.Add(Factory.Column(column.Name, dataType, column.AllowNulls, quoteType));
}
}
return(columns);
}
private DeclareVariableStatement CreateDeclareVariableStatement(Identifier name, DataTypeReference type, ScalarExpression value)
{
DeclareVariableStatement statement = new DeclareVariableStatement();
statement.Declarations.Add(new DeclareVariableElement()
{
Value = value,
DataType = type,
VariableName = name
});
return(statement);
}
public static DbType ResolveToDbDataType(DataTypeReference dataType)
{
if (dataType.Name.Count == 1)
{
string typeName = dataType.Name[0].Value;
if (string.Equals("INT", typeName, StringComparison.OrdinalIgnoreCase))
{
//return typeof(int);
return(DbType.Int32);
}
if (string.Equals("BIT", typeName, StringComparison.OrdinalIgnoreCase))
{
//return typeof(bool);
return(DbType.Boolean);
}
if (string.Equals("NVARCHAR", typeName, StringComparison.OrdinalIgnoreCase))
{
SqlDataTypeReference sqlDataType = (SqlDataTypeReference)dataType;
string maxLen = sqlDataType.Parameters[0].Value;
//dataType.p
//return typeof(string);
return(DbType.String);
}
if (string.Equals("SMALLINT", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Int16);
}
if (string.Equals("DATETIME", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.DateTime);
}
if (string.Equals("BIGINT", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Int64);
}
if (string.Equals("TINYINT", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Byte);
}
if (string.Equals("UNIQUEIDENTIFIER", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Guid);
}
if (string.Equals("VARBINARY", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Binary);
}
if (string.Equals("DECIMAL", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Decimal);
}
if (string.Equals("DATETIMEOFFSET", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.DateTimeOffset);
}
if (string.Equals("NCHAR", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.String);
}
if (string.Equals("XML", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Xml);
}
if (string.Equals("DATE", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Date);
}
if (string.Equals("TIME", typeName, StringComparison.OrdinalIgnoreCase))
{
return(DbType.Time);
}
throw new NotImplementedException("typeName:" + typeName);
}
else
{
throw new NotImplementedException("Name.Count:" + dataType.Name.Count);
}
}
public override void ExplicitVisit(DataTypeReference fragment)
{
_fragments.Add(fragment);
}
public sealed override void Visit(DataTypeReference node)
{
base.Visit(node);
}
private static (string typeName, string[] attributes) GetType(DataTypeReference t, IEnumerable <ConstraintDefinition> constraints)
{
var name = t.Name.Identifiers.Last().Value;
if (IsNullable(constraints))
{
switch (name)
{
case "INT": return("int?", None);
case "BIGINT": return("long?", None);
case "SMALLINT": return("short?", None);
case "TINYINT": return("byte?", None);
case "BIT": return("bool?", None);
case "NVARCHAR":
case "VARCHAR": return("string", StringLength(t) is string sl ? new[] { sl } : None);
case "DATETIMEOFFSET": return("DateTimeOffset?", None);
case "DATETIME2": return("DateTime?", None);
case "timestamp":
case "ROWVERSION": return("byte[]", new[] { Timestamp });
case "BINARY":
case "VARBINARY": return("byte[]", ArrayLength(t) is string al ? new[] { al } : None);
default: throw new NotSupportedException(name);
}
}
else
{
switch (name)
{
case "INT": return("int", None);
case "BIGINT": return("long", None);
case "SMALLINT": return("short", None);
case "TINYINT": return("byte", None);
case "BIT": return("bool", None);
case "NVARCHAR":
case "VARCHAR": return("string", StringLength(t) is string sl ? new[] { Required, sl } : new[] { Required });
case "DATETIMEOFFSET": return("DateTimeOffset", None);
case "DATETIME2": return("DateTime", None);
case "ROWVERSION": return("byte[]", new[] { Timestamp });
case "BINARY":
case "VARBINARY": return("byte[]", ArrayLength(t) is string al ? new[] { Required, al } : new[] { Required });
default: throw new NotSupportedException(name);
}
}
}
/// <summary>
/// Gets the arguments for SQL database types, like the length, precision, and scale.
/// </summary>
/// <param name="dataType">The column data type</param>
/// <returns>The type arguments</returns>
protected static IEnumerable <ArgumentSyntax> GetDataTypeSpecificConstructorArguments(DataTypeReference dataType)
{
if (dataType is ParameterizedDataTypeReference parameterizedDataType)
{
return(parameterizedDataType.Parameters.Select(p => SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(p.LiteralType == LiteralType.Max ? -1 : int.Parse(p.Value))))));
}
return(Array.Empty <ArgumentSyntax>());
}
public static string DataType(DataTypeReference dtype)
{
switch (dtype.GetType().Name)
{
case "SqlDataTypeReference":
{
var sqltype = dtype as SqlDataTypeReference;
var sb = new StringBuilder(1024);
sb.Append(SchemaObjectName(sqltype.Name));
if (sqltype.Parameters.Any())
{
sb.Append("(");
for (var j = 0; j < sqltype.Parameters.Count; ++j)
{
if (j > 0)
sb.Append(", ");
sb.Append(sqltype.Parameters[j].Value);
}
sb.Append(")");
}
return sb.ToString();
}
default:
return "";
}
}
/// <summary>
/// Gets the arguments for SQL database types, like the length, precision, and scale.
/// </summary>
/// <param name="dataType">The column data type</param>
/// <param name="collation">The column collation, if any</param>
/// <returns>The type arguments</returns>
protected static IEnumerable <ArgumentSyntax> GetDataTypeSpecificConstructorArguments(DataTypeReference dataType, Identifier collation)
{
if (dataType is ParameterizedDataTypeReference parameterizedDataType)
{
foreach (var parameter in parameterizedDataType.Parameters)
{
yield return(Argument(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(parameter.LiteralType == LiteralType.Max ? -1 : int.Parse(parameter.Value)))));
}
}
if (collation != null)
{
yield return(Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(collation.Value))));
}
}
public sealed override void ExplicitVisit(DataTypeReference node)
{
base.ExplicitVisit(node);
}
private WDataTypeReference ParseDataType(DataTypeReference dataType)
{
if (dataType == null)
return null;
var pDataType = dataType as ParameterizedDataTypeReference;
if (pDataType == null)
throw new NotImplementedException();
var wDataType = new WParameterizedDataTypeReference
{
Name = ParseSchemaObjectName(pDataType.Name),
FirstTokenIndex = pDataType.FirstTokenIndex,
LastTokenIndex = pDataType.LastTokenIndex
};
if (pDataType.Parameters == null)
return wDataType;
wDataType.Parameters = new List<Literal>(pDataType.Parameters.Count);
foreach (var param in pDataType.Parameters)
wDataType.Parameters.Add(param);
return wDataType;
}
public override void ExplicitVisit(DataTypeReference node) { this.action(node); }
