private IEnumerable <ResultDefinition> partitionRecord(string record)
{
IEnumerable <ResultDefinition> validationResults = new List <ResultDefinition>();
var outerPipeline = new Pipeline <ResultDefinition>();
outerPipeline.Register(new LengthChecker());
var rowDefinition = new ResultDefinition
{
MaxRecordLength = schema.TotalWidth,
RowNumber = rowNumber,
Record = record,
};
var result = outerPipeline.Execute(rowDefinition);
if (result != null && result.Any())
{
return(result);
}
var innerPipeline = new Pipeline <ResultDefinition>();
innerPipeline.Register(new TypeChecker());
innerPipeline.Register(new AlignmentChecker());
innerPipeline.Register(new AllowedValuesChecker());
WindowCollection windows = schema.Windows;
ColumnCollection definitions = schema.ColumnDefinitions;
string[] values = new string[windows.Count];
int offset = 0;
for (int index = 0; index != values.Length; ++index)
{
Window window = windows[index];
IColumnDefinition definition = definitions[index];
string value = record.Substring(offset, window.Width);
values[index] = value;
offset += window.Width;
var dataDefinition = new ResultDefinition
{
RawValue = value,
ColumnDefinition = definition,
Window = window,
MaxRecordLength = schema.TotalWidth,
RowNumber = rowNumber,
Record = record
};
var innerResult = innerPipeline.Execute(dataDefinition);
if (innerResult != null && innerResult.Any())
{
validationResults = validationResults.Concat(innerResult);
}
}
return(validationResults);
}
private static string getErrorMessage(ISchema schema, IColumnDefinition definition, string value)
{
int position = schema.GetOrdinal(definition.ColumnName);
string message = String.Format(null, SharedResources.InvalidColumnConversion, value, definition.ColumnType.FullName, definition.ColumnName, position);
return(message);
}
private void BuildAddColumnNode(IColumnDefinition column, IAddTableNode parent)
{
IAddColumnNode addColumnNode = new AddColumnNode(parent, column.Name);
parent.ChildNodes.Add(addColumnNode);
SemanticModelUtil.Copy(column, addColumnNode);
}
public void InitFromColonneSource(IColumnDeEasyQuery colonne, CODEQBase objetDeQuery)
{
m_colonneSource = colonne;
CEasyQuery query = objetDeQuery.Query;
if (query != null)
{
//cherche la source
ITableDefinition tableDef = null;
IColumnDefinition colDef = null;
IsReadOnly = true;
Description = "";
if (query.FindSource(colonne, objetDeQuery, out tableDef, out colDef))
{
CColumnDefinitionSNMP colSnmp = colDef as CColumnDefinitionSNMP;
if (colSnmp != null)
{
if (tableDef is CTableDefinitionSNMP ||
tableDef is CTableDefinitionSnmpOfScalar)
{
Description = colSnmp.Description;
IsReadOnly = colSnmp.IsReadOnly;
}
}
}
}
}
public CustomPropertyMapping(IColumnDefinition column, IMemberAccessor member, int fileIndex, int workIndex)
{
this.column = column;
this.member = member;
this.FileIndex = fileIndex;
this.WorkIndex = workIndex;
}
public static Tolerance Build(IColumnDefinition columnDefinition)
{
if (columnDefinition.Role != ColumnRole.Value)
throw new ArgumentException("The ColumnDefinition must have have a role defined as 'Value' and is defined as 'Key'", "columnDefinition");
return Build(columnDefinition.Type, columnDefinition.Tolerance);
}
public ComplexMapperColumn(IColumnDefinition column, IMapper <TEntity> mapper)
{
this.column = column;
this.reader = mapper.GetReader();
this.writer = mapper.GetWriter();
this.workCount = mapper.WorkCount;
}
/// <summary>
/// Formats the given values assuming that they are in the same order as the column definitions.
/// </summary>
/// <param name="context">The metadata for the record currently being processed.</param>
/// <param name="values">The values to format.</param>
/// <returns>The formatted values.</returns>
protected string[] FormatValuesBase(IRecordContext context, object[] values)
{
string[] formattedValues = new string[ColumnDefinitions.Count];
for (int columnIndex = 0, valueIndex = 0; columnIndex != ColumnDefinitions.Count; ++columnIndex)
{
IColumnDefinition definition = ColumnDefinitions[columnIndex];
if (definition is IMetadataColumn)
{
var columnContext = GetColumnContext(context, columnIndex, valueIndex);
var formattedValue = Format(columnContext, definition, valueIndex, null);
formattedValues[columnIndex] = formattedValue;
++valueIndex;
}
else if (!definition.IsIgnored)
{
var isContextDisabled = context.ExecutionContext.Options.IsColumnContextDisabled;
var columnContext = isContextDisabled ? null : GetColumnContext(context, columnIndex, valueIndex);
var value = values[valueIndex];
string formattedValue = Format(columnContext, definition, valueIndex, value);
formattedValues[columnIndex] = formattedValue;
++valueIndex;
}
}
return(formattedValues);
}
public WriteOnlyPropertyMapping(IColumnDefinition column, string name, int fileIndex, int workIndex)
{
this.column = column;
this.name = name;
this.FileIndex = fileIndex;
this.WorkIndex = workIndex;
}
public ComplexMapperColumn(IColumnDefinition column, IMapper <TEntity> mapper)
{
this.column = column;
reader = mapper.GetReader();
writer = mapper.GetWriter();
logicalCount = mapper.LogicalCount;
}
//---------------------------------------
private DataTable GetTableSnmp(CTableDefinitionSNMP tableSNMP, params string[] strIdsColonnesSource)
{
List <uint[]> lstCols = new List <uint[]>();
if (strIdsColonnesSource != null)
{
foreach (string strIdCol in strIdsColonnesSource)
{
try
{
lstCols.Add(ObjectIdentifier.Convert(strIdCol));
}
catch { }
}
}
DataTable table = m_interrogateur.GetTable(tableSNMP.OID, lstCols.ToArray());
if (table != null)
{
foreach (DataColumn col in table.Columns)
{
IColumnDefinition colSNMP = tableSNMP.Columns.FirstOrDefault(
c => c is CColumnDefinitionSNMP &&
((CColumnDefinitionSNMP)c).OIDString == col.ColumnName);
if (colSNMP != null)
{
col.ColumnName = colSNMP.ColumnName;
}
}
return(table);
}
return(null);
}
//-----------------------------------------
public CColumnEQFromSource(IColumnDefinition column)
{
m_strIdColonne = Guid.NewGuid().ToString();
m_strNomColonne = column.ColumnName;
m_strIdColonneSource = column.Id;
m_typeDonnee = column.DataType;
}
private string GetSystemValue(T entity, IColumnDefinition definition, bool isUpdate)
{
var name = definition.Name;
if (name == SystemColumns.Id)
{
return(entity.Id.GetSqlSyntax());
}
else if (name == SystemColumns.Created)
{
return(entity.Created.GetSqlSyntax());
}
else if (name == SystemColumns.CreatedBy)
{
return(entity.CreatedBy.GetSqlSyntax());
}
else if (name == SystemColumns.Modified)
{
return(entity.Modified.GetSqlSyntax());
}
else if (name == SystemColumns.ModifiedBy)
{
return(entity.ModifiedBy.GetSqlSyntax());
}
else if (name == SystemColumns.Version)
{
if (isUpdate)
{
return(name + " + 1");
}
return(entity.Version.GetSqlSyntax());
}
return(null);
}
public static Rounding Build(IColumnDefinition columnDefinition)
{
if (columnDefinition.Role != ColumnRole.Value)
{
throw new ArgumentException("The ColumnDefinition must have have a role defined as 'Value' and is defined as 'Key'", "columnDefinition");
}
Rounding rounding = null;
switch (columnDefinition.Type)
{
case ColumnType.Text:
break;
case ColumnType.Numeric:
rounding = new NumericRounding(double.Parse(columnDefinition.RoundingStep, NumberFormatInfo.InvariantInfo), columnDefinition.RoundingStyle);
break;
case ColumnType.DateTime:
rounding = new DateTimeRounding(TimeSpan.Parse(columnDefinition.RoundingStep, NumberFormatInfo.InvariantInfo), columnDefinition.RoundingStyle);
break;
case ColumnType.Boolean:
break;
default:
break;
}
return(rounding);
}
/// <summary>
/// Formats the given values assuming that they are in the same order as the column definitions.
/// </summary>
/// <param name="context">The metadata for the record currently being processed.</param>
/// <param name="values">The values to format.</param>
/// <returns>The formatted values.</returns>
internal string[] FormatValues(IRecoverableRecordContext context, object[] values)
{
string[] formattedValues = new string[ColumnDefinitions.Count];
for (int columnIndex = 0, valueIndex = 0; columnIndex != ColumnDefinitions.Count; ++columnIndex)
{
IColumnDefinition definition = ColumnDefinitions[columnIndex];
if (definition is IMetadataColumn)
{
var columnContext = GetColumnContext(context, columnIndex, valueIndex);
var formattedValue = FormatWithContext(columnContext, null);
formattedValues[columnIndex] = formattedValue;
++valueIndex;
}
else if (!definition.IsIgnored)
{
var value = values[valueIndex];
var formattedValue = FormatValue(context, columnIndex, valueIndex, value);
formattedValues[columnIndex] = formattedValue;
++valueIndex;
}
else
{
var formattedValue = FormatValue(context, columnIndex, -1, null);
formattedValues[columnIndex] = formattedValue;
}
}
return(formattedValues);
}
public System.Data.DataTable GetData(ITableDefinition tableDefinition)
{
DataTable result = null;
CTableDefinitionSNMP tableSNMP = tableDefinition as CTableDefinitionSNMP;
if (tableSNMP != null)
{
result = Messenger.ReadTable(VersionCode.V2,
new IPEndPoint(IPAddress.Parse(m_strIp), m_nPort),
new OctetString(m_strCommunaute),
new ObjectIdentifier(tableSNMP.OID),
1000);
if (result != null)
{
foreach (DataColumn col in result.Columns)
{
IColumnDefinition colSNMP = tableDefinition.Columns.FirstOrDefault(
c => c is CColumnDefinitionSNMP &&
((CColumnDefinitionSNMP)c).OIDString == col.ColumnName);
if (colSNMP != null)
{
col.ColumnName = colSNMP.ColumnName;
}
}
}
}
return(result);
}
internal ColumnProcessingException(ISchema schema, IColumnDefinition definition, string value, Exception innerException)
: base(getErrorMessage(schema, definition, value), innerException)
{
this.Schema = schema;
this.ColumnDefinition = definition;
this.ColumnValue = value;
}
/// <summary>
/// Parses the given values assuming that they are in the same order as the column definitions.
/// </summary>
/// <param name="metadata">The current metadata for the process.</param>
/// <param name="values">The values to parse.</param>
/// <returns>The parsed objects.</returns>
protected object[] ParseValuesBase(IProcessMetadata metadata, string[] values)
{
object[] parsedValues = new object[definitions.PhysicalCount];
for (int columnIndex = 0, sourceIndex = 0, destinationIndex = 0; columnIndex != definitions.Count; ++columnIndex)
{
IColumnDefinition definition = definitions[columnIndex];
if (definition is IMetadataColumn metaColumn)
{
object value = metaColumn.GetValue(metadata);
parsedValues[destinationIndex] = value;
++destinationIndex;
}
else if (!definition.IsIgnored)
{
string rawValue = values[sourceIndex];
++sourceIndex;
object parsedValue = parse(definition, rawValue);
parsedValues[destinationIndex] = parsedValue;
++destinationIndex;
}
else
{
++sourceIndex;
}
}
return(parsedValues);
}
//---------------------------------------------------------------
private void m_btnOk_Click(object sender, EventArgs e)
{
if (m_txtNomTable.Text.Length == 0)
{
MessageBox.Show(I.T("Please enter a table name|20004"));
return;
}
m_tableFromDataHotel.NomFinal = m_txtNomTable.Text;
m_tableFromDataHotel.UseCache = m_chkUseCache.Checked;
List <IColumnDeEasyQuery> lst = new List <IColumnDeEasyQuery>();
foreach (ListViewItem item in m_wndListeColonnes.Items)
{
if (item.Checked)
{
IColumnDefinition colFromSource = item.Tag as IColumnDefinition;
if (colFromSource != null)
{
IColumnDeEasyQuery newCol = m_tableFromDataHotel.GetColonneFor(colFromSource);
if (newCol == null)
{
newCol = new CColumnEQFromSource(colFromSource);
}
newCol.ColumnName = item.Text;
lst.Add(newCol);
}
CColonneCalculeeDataHotel colCalc = item.Tag as CColonneCalculeeDataHotel;
if (colCalc != null)
{
colCalc.ColumnName = item.Text;
lst.Add(colCalc);
}
}
}
m_tableFromDataHotel.SetColonnesOrCalculees(lst);
List <CColonneEQCalculee> colsCalc = new List <CColonneEQCalculee>();
foreach (CColonneEQCalculee col in m_ctrlFormulesNommees.GetFormules())
{
colsCalc.Add(col);
}
m_tableFromDataHotel.ColonnesCalculees = colsCalc;
CResultAErreur result = m_panelOptions.MajChamps(m_tableFromDataHotel);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult = DialogResult.OK;
Close();
}
//-------------------------------------------------------
/// <summary>
/// Retourne la colonne finale associé à une colonne de la base
/// </summary>
/// <param name="colonne"></param>
/// <returns></returns>
public IColumnDeEasyQuery GetColonneFor(IColumnDefinition colonne)
{
if (colonne != null)
{
return(m_listeColonnes.FirstOrDefault(c => c is CColumnEQFromSource && ((CColumnEQFromSource)c).IdColumnSource == colonne.Id));
}
return(null);
}
public Column(IColumnDefinition columnDefinition)
{
ColumnDefinition = columnDefinition;
if (columnDefinition.Width.IsAbsolute)
{
Size = columnDefinition.Width.Value;
}
}
protected override string GetEntityValue(Customer entity, IColumnDefinition definition, bool isUpdate)
{
if (definition.Name == "Name")
{
return(entity.Name.GetSqlSyntax());
}
throw new NotSupportedException();
}
public static Tolerance Build(IColumnDefinition columnDefinition)
{
if (columnDefinition.Role != ColumnRole.Value)
{
throw new ArgumentException("The ColumnDefinition must have have a role defined as 'Value' and is defined as 'Key'", "columnDefinition");
}
return(Build(columnDefinition.Type, columnDefinition.Tolerance));
}
public IndexTrackingColumn(
IColumnDefinition columnDefinition,
List <int> physicalIndexes,
List <int> logicalIndexes)
{
this.columnDefinition = columnDefinition;
this.physicalIndexes = physicalIndexes;
this.logicalIndexes = logicalIndexes;
}
public ConversionColumn(
IColumnDefinition columnDefinition,
Func <TSource, TDestination> parser,
Func <TDestination, TSource> formatter)
: base(columnDefinition.ColumnName)
{
this.columnDefinition = columnDefinition;
this.parser = parser;
this.formatter = formatter;
}
private string GetValue(T entity, IColumnDefinition definition, bool isUpdate)
{
var value = GetSystemValue(entity, definition, isUpdate);
if (value == null)
{
value = GetEntityValue(entity, definition, isUpdate);
}
return(value);
}
private static string FormatWithoutContext(IColumnDefinition definition, int position, object value)
{
try
{
return(definition.Format(null, value));
}
catch (Exception exception)
{
throw new ColumnProcessingException(definition, position, value, exception);
}
}
//------------------------------------------------
public void AddColumn(IColumnDefinition column)
{
if (GetColumn(column.Id) == null)
{
m_listeColonnes.Add(column);
if (column.Table != this)
{
column.Table = this;
}
}
}
/// <summary>
/// Adds a column to the schema, using the given definition to define it.
/// </summary>
/// <param name="definition">The definition of the column to add.</param>
/// <param name="window">Describes the column</param>
/// <returns>The current schema.</returns>
public FixedLengthSchema AddColumn(IColumnDefinition definition, Window window)
{
if (window == null)
{
throw new ArgumentNullException("window");
}
AddColumnBase(definition);
windows.Add(window);
totalWidth += window.Width;
return this;
}
/// <summary>
/// Adds a column to the schema, using the given definition to define it.
/// </summary>
/// <param name="definition">The definition of the column to add.</param>
/// <param name="window">Describes the column</param>
/// <returns>The current schema.</returns>
public FixedLengthSchema AddColumn(IColumnDefinition definition, Window window)
{
if (window == null)
{
throw new ArgumentNullException("window");
}
AddColumnBase(definition);
windows.Add(window);
totalWidth += window.Width;
return(this);
}
private static object ParseWithoutContext(IColumnDefinition definition, int position, string rawValue)
{
try
{
object parsedValue = definition.Parse(null, rawValue);
return(parsedValue);
}
catch (Exception exception)
{
throw new ColumnProcessingException(definition, position, rawValue, exception);
}
}
public static PocoColumn FromColumnDefinition(IColumnDefinition columnDefinition)
{
return(new PocoColumn
{
// Default the column name to the prop/field name if not specified
ColumnName = columnDefinition.ColumnName ?? columnDefinition.MemberInfo.Name,
// Default the column type to the prop/field type if not specified
ColumnType = columnDefinition.ColumnType ?? columnDefinition.MemberInfoType,
MemberInfo = columnDefinition.MemberInfo,
MemberInfoType = columnDefinition.MemberInfoType
});
}
private object parse(IColumnDefinition definition, string rawValue)
{
try
{
object parsedValue = definition.Parse(rawValue);
return(parsedValue);
}
catch (Exception exception)
{
throw new ColumnProcessingException(this, definition, rawValue, exception);
}
}
public static PocoColumn FromColumnDefinition(IColumnDefinition columnDefinition)
{
return new PocoColumn
{
// Default the column name to the prop/field name if not specified
ColumnName = columnDefinition.ColumnName ?? columnDefinition.MemberInfo.Name,
// Default the column type to the prop/field type if not specified
ColumnType = columnDefinition.ColumnType ?? columnDefinition.MemberInfoType,
MemberInfo = columnDefinition.MemberInfo,
MemberInfoType = columnDefinition.MemberInfoType,
SecondaryIndex = columnDefinition.SecondaryIndex,
IsCounter = columnDefinition.IsCounter,
IsStatic = columnDefinition.IsStatic
};
}
/// <summary>
/// Copies all properties from <paramref name="columnDefinition"/> to appropriate <see cref="IAstNodeProperty"/>
/// objects and adds them to <paramref name="columnNode"/>.
/// </summary>
/// <param name="columnDefinition"></param>
/// <param name="columnNode"></param>
public static void CopyProperties(IColumnDefinition columnDefinition, IColumnNode columnNode)
{
if(columnDefinition.Type != null)
AddProperty(columnNode, MdlSyntax.Type, columnDefinition.Type.Value.ToString());
if(columnDefinition.Nullable.HasValue)
AddProperty(columnNode, MdlSyntax.Nullable, columnDefinition.Nullable.Value.ToString().ToLower());
if(columnDefinition.Length.HasValue)
AddProperty(columnNode, MdlSyntax.Length, columnDefinition.Length.Value);
if(columnDefinition.Precision.HasValue)
AddProperty(columnNode, MdlSyntax.Precision, columnDefinition.Precision.Value);
if(columnDefinition.Scale.HasValue)
AddProperty(columnNode, MdlSyntax.Scale, columnDefinition.Scale.Value);
if(columnDefinition.PrimaryKey.GetValueOrDefault(false))
AddProperty(columnNode, MdlSyntax.PrimaryKey, "true");
if(columnDefinition.Identity.GetValueOrDefault(false))
AddProperty(columnNode, MdlSyntax.Identity, "true");
}
public static Rounding Build(IColumnDefinition columnDefinition)
{
if (columnDefinition.Role != ColumnRole.Value)
throw new ArgumentException("The ColumnDefinition must have have a role defined as 'Value' and is defined as 'Key'", "columnDefinition");
Rounding rounding=null;
switch (columnDefinition.Type)
{
case ColumnType.Text:
break;
case ColumnType.Numeric:
rounding = new NumericRounding(double.Parse(columnDefinition.RoundingStep, NumberFormatInfo.InvariantInfo), columnDefinition.RoundingStyle);
break;
case ColumnType.DateTime:
rounding = new DateTimeRounding(TimeSpan.Parse(columnDefinition.RoundingStep, NumberFormatInfo.InvariantInfo), columnDefinition.RoundingStyle);
break;
case ColumnType.Boolean:
break;
default:
break;
}
return rounding;
}
protected virtual string GetNullabilitySpecification(IColumnDefinition column)
{
return column.Nullable.HasValue ?
column.Nullable.Value ?
"null" :
"not null" :
"";
}
protected string MapToNativeType(IColumnDefinition columnDefinition)
{
if(!columnDefinition.Type.HasValue)
throw new DbPlatformException(string.Format("Could not resolve type in {0}", GetFragment(((IAstNode)columnDefinition).Parent)));
if(!columnDefinition.Length.HasValue && !columnDefinition.Scale.HasValue && !columnDefinition.Precision.HasValue)
return Platform.TypeMapper.MapToNativeType(columnDefinition.Type.Value, columnDefinition.Length);
return columnDefinition.Length.HasValue ?
Platform.TypeMapper.MapToNativeType(columnDefinition.Type.Value, columnDefinition.Length) :
Platform.TypeMapper.MapToNativeType(columnDefinition.Type.Value, columnDefinition.Scale, columnDefinition.Precision);
}
/// <summary>
/// Initializes a new instance of the <see cref="ColumnDefinition"/> class.
/// </summary>
/// <param name="columnDefinition"></param>
public ColumnDefinition(IColumnDefinition columnDefinition) :
this(columnDefinition.Name, columnDefinition.Table, columnDefinition.Type, columnDefinition.Nullable, columnDefinition.Length,
columnDefinition.Scale, columnDefinition.Precision, columnDefinition.PrimaryKey, columnDefinition.Identity)
{
}
private static void BindColumnProperties(IColumnNode columnNode, IColumnDefinition columnDefinition)
{
if(columnNode.Properties[MdlSyntax.PrimaryKey] != null)
columnNode.PrimaryKey = columnDefinition.PrimaryKey =
columnNode.Properties.AsBoolean(MdlSyntax.PrimaryKey);
if (columnNode.Properties[MdlSyntax.Nullable] != null)
columnNode.Nullable = columnDefinition.Nullable =
columnNode.Properties.AsBoolean(MdlSyntax.Nullable);
if (columnNode.Properties[MdlSyntax.Length] != null)
columnNode.Length = columnDefinition.Length =
AstNodePropertyUtil.AsInteger(columnNode.Properties, MdlSyntax.Length);
//
// Type aliases have already been resolved, so we can freely parse textual type representation.
if(columnNode.Properties[MdlSyntax.Type] != null)
{
string textualType = AstNodePropertyUtil.AsString(columnNode.Properties, MdlSyntax.Type);
try
{
columnNode.Type = columnDefinition.Type =
(DbType)Enum.Parse(typeof(DbType), textualType, true);
} // try
catch(ArgumentException e)
{
throw new MdlCompilerException(string.Format(MdlCompilerResources.UnknownType, textualType), e);
} // catch
} // if
if(columnNode.Properties[MdlSyntax.Scale] != null)
columnNode.Scale = columnDefinition.Scale =
AstNodePropertyUtil.AsInteger(columnNode.Properties, MdlSyntax.Scale);
if(columnNode.Properties[MdlSyntax.Precision] != null)
columnNode.Precision = columnDefinition.Precision =
AstNodePropertyUtil.AsInteger(columnNode.Properties, MdlSyntax.Precision);
if(columnNode.Properties[MdlSyntax.Identity] != null)
columnNode.Identity = columnDefinition.Identity =
Convert.ToBoolean(AstNodePropertyUtil.AsString(columnNode.Properties, MdlSyntax.Identity));
if(columnNode.Properties[MdlSyntax.Table] != null)
columnNode.Table = columnDefinition.Table =
AstNodePropertyUtil.AsString(columnNode.Properties, MdlSyntax.Table);
}
private void AlterColumn(IColumnDefinition definition, IAlterColumnNode alterColumnNode)
{
if(alterColumnNode.Length.HasValue)
definition.Length = alterColumnNode.Length;
if(alterColumnNode.Nullable.HasValue)
definition.Nullable = alterColumnNode.Nullable;
}
protected virtual string GetAlterColumnDefinition(IColumnDefinition columnDefinition)
{
StringBuilder columnDefinitionBuilder = new StringBuilder();
columnDefinitionBuilder.Append(Platform.Dialect.EscapeIdentifier(columnDefinition.Name));
columnDefinitionBuilder.AppendFormat(" {0}", MapToNativeType(columnDefinition));
if(columnDefinition.Nullable.HasValue)
columnDefinitionBuilder.AppendFormat(" {0}", columnDefinition.Nullable.Value ? "null" : "not null");
return columnDefinitionBuilder.ToString();
}
