/// <summary>
/// move the column up in order
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btUp_Click(object sender, RoutedEventArgs e)
{
//get the selected item
if (lbColumns.SelectedItem == null)
{
return;
}
IColumnMetadata col = lbColumns.SelectedItem as IColumnMetadata;
//check we are first
if (col.OrdinalPosition == 0)
{
return;
}
//decrement position
var swap = _Columns.FirstOrDefault(c => c.OrdinalPosition == col.OrdinalPosition - 1);
if (swap != null)
{
swap.OrdinalPosition++;
}
col.OrdinalPosition--;
Columns.View.Refresh();
}
public void AddColumn(IColumnMetadata column)
{
if (column != null)
{
columns.Add(column);
}
}
public string[] SqlAlterStrings(Dialect.Dialect dialect, IMapping p, ITableMetadata tableInfo, string defaultCatalog,
string defaultSchema)
{
StringBuilder root =
new StringBuilder("alter table ").Append(GetQualifiedName(dialect, defaultCatalog, defaultSchema)).Append(' ').
Append(dialect.AddColumnString);
var results = new List <string>(ColumnSpan);
foreach (Column column in ColumnIterator)
{
IColumnMetadata columnInfo = tableInfo.GetColumnMetadata(column.Name);
if (columnInfo != null)
{
continue;
}
// the column doesnt exist at all.
StringBuilder alter =
new StringBuilder(root.ToString()).Append(' ').Append(column.GetQuotedName(dialect)).Append(' ').Append(
column.GetSqlType(dialect, p));
string defaultValue = column.DefaultValue;
if (!string.IsNullOrEmpty(defaultValue))
{
alter.Append(" default ").Append(defaultValue);
if (column.IsNullable)
{
alter.Append(dialect.NullColumnString);
}
else
{
alter.Append(" not null");
}
}
bool useUniqueConstraint = column.Unique && dialect.SupportsUnique &&
(!column.IsNullable || dialect.SupportsNotNullUnique);
if (useUniqueConstraint)
{
alter.Append(" unique");
}
if (column.HasCheckConstraint && dialect.SupportsColumnCheck)
{
alter.Append(" check(").Append(column.CheckConstraint).Append(") ");
}
string columnComment = column.Comment;
if (columnComment != null)
{
alter.Append(dialect.GetColumnComment(columnComment));
}
results.Add(alter.ToString());
}
return(results.ToArray());
}
/// <summary>
/// move the column down in order
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btDown_Click(object sender, RoutedEventArgs e)
{
//get the selected item
if (lbColumns.SelectedItem == null)
{
return;
}
IColumnMetadata col = lbColumns.SelectedItem as IColumnMetadata;
//get the column position
int position = 0;
if (_Columns.Count > 0)
{
position = _Columns.Max(c => c.OrdinalPosition);
}
//check if we are max
if (position == col.OrdinalPosition)
{
return;
}
//decrement position
var swap = _Columns.FirstOrDefault(c => c.OrdinalPosition == col.OrdinalPosition + 1);
if (swap != null)
{
swap.OrdinalPosition--;
}
col.OrdinalPosition++;
Columns.View.Refresh();
}
public void ValidateColumns(Dialect.Dialect dialect, IMapping mapping, ITableMetadata tableInfo)
{
IEnumerable <Column> iter = ColumnIterator;
foreach (Column column in iter)
{
IColumnMetadata columnInfo = tableInfo.GetColumnMetadata(column.Name);
if (columnInfo == null)
{
throw new HibernateException(string.Format("Missing column: {0} in {1}", column.Name,
Qualify(tableInfo.Catalog, tableInfo.Schema, tableInfo.Name)));
}
else
{
//TODO: Add new method to ColumnMetadata :getTypeCode
bool typesMatch = column.GetSqlType(dialect, mapping).ToLower().StartsWith(columnInfo.TypeName.ToLower());
//|| columnInfo.get() == column.GetSqlTypeCode(mapping);
if (!typesMatch)
{
throw new HibernateException(string.Format("Wrong column type in {0} for column {1}. Found: {2}, Expected {3}",
Qualify(tableInfo.Catalog, tableInfo.Schema, tableInfo.Name),
column.Name, columnInfo.TypeName.ToLower(),
column.GetSqlType(dialect, mapping)));
}
}
}
}
public void ColumnLambdaScan <T>(IColumnMetadata column, Func <T, bool> lambda)
{
var planItem = new RowScanPlanItem(_journal, _tx);
planItem.AddLambdaScan(column, lambda);
_planHead = planItem;
}
protected virtual object CreateId(IColumnMetadata[] keyColumns,ITableMetadata tableMetadata)
{
if (keyColumns.Length == 1)
{
var id = new id();
id.generator = GetGenerator(keyColumns[0],tableMetadata);
id.type1 = typeConverter.GetNHType(keyColumns[0]);
id.name = currentContext.NamingStrategy.GetIdPropertyNameFromColumnName(keyColumns[0].Name);
id.column1 = 0 == string.Compare(id.name, keyColumns[0].Name, true) ? null : keyColumns[0].Name;// keyColumns[0].Name;
return id;
}
else
if (keyColumns.Length > 1)
{
var cid = new compositeid();
string entityName = currentContext.NamingStrategy.GetEntityNameFromTableName(tableMetadata.Name);
cid.@class = currentContext.NamingStrategy.GetClassNameForComponentKey(entityName);
List<keyproperty> keyps = new List<keyproperty>();
cid.name = currentContext.NamingStrategy.GetNameForComponentKey(entityName,cid.@class);
foreach (IColumnMetadata meta in keyColumns)
{
keyproperty kp = new keyproperty();
kp.name = currentContext.NamingStrategy.GetPropertyNameFromColumnName(meta.Name);
kp.column1 = 0 == string.Compare(kp.name, meta.Name, true) ? null : meta.Name;
kp.length = meta.ColumnSize != 0 ? meta.ColumnSize.ToString() : null;
kp.type1 = typeConverter.GetNHType(meta);
keyps.Add(kp);
}
cid.Items = keyps.ToArray();
return cid;
}
return null;
}
private IPlanItem CreateLastestByIdPlanItem(IColumnMetadata column)
{
var rowScan = new RowScanPlanItem(_journal, _tx);
rowScan.ApplyLastestByIdPlanItem(column);
return(rowScan);
}
/// <summary>
/// delete an item given its catalog table
/// </summary>
/// <param name="item"></param>
/// <param name="table"></param>
public void DeleteItem(IDataItem item, bool HardDelete)
{
//the table to call delete item with
IReferenceDataTable delete_table = null;
//check if this is a reference table
if (TableMetadata.ReferenceTable)
{
//get the reference table
delete_table = (IReferenceDataTable)this;
}
else
{
//get the mod field
IColumnMetadata column = TableMetadata.ColumnsMetadata[TableMetadata.ModField];
//get the value to mode
object obj = item.GetType().GetField(column.FieldMapping).GetValue(item);
Int64 id = Convert.ToInt64(obj);
//mod to get the bucket index
Int64 bucket = id % TableMetadata.CatalogMetadata.Catalog.ComputeNode.GlobalBucketCount;
//get the bucket table
delete_table = TableMetadata.CatalogMetadata.Catalog.Buckets[bucket].BucketDataTables[TableMetadata.TableName];
}
//call delete
if (delete_table != null)
{
DeleteItem(item, delete_table, HardDelete);
}
}
public void ColumnScan <T>(IColumnMetadata column, T literal)
{
var planItem = new RowScanPlanItem(_journal, _tx);
planItem.AddContainsScan(column, literal);
_planHead = planItem;
}
protected virtual generator GetGenerator(IColumnMetadata iColumnMetadata, ITableMetadata tableMetaData)
{
if (currentContext.TableExceptions.HasException(tableMetaData.Name, tableMetaData.Catalog, tableMetaData.Schema))
{
var exc = currentContext.TableExceptions.GetTableException(tableMetaData.Name, tableMetaData.Catalog, tableMetaData.Schema);
if (exc.primarykey != null && exc.primarykey.generator != null)
{
generator g = new generator();
g.@class = exc.primarykey.generator.@class;
if (null != exc.primarykey.generator.param)
{
List <param> parms = new List <param>();
foreach (var p in exc.primarykey.generator.param)
{
parms.Add(new param()
{
name = p.name, Text = new string[] { p.Value }
});
}
g.param = parms.ToArray();
}
return(g);
}
}
logger.Info(string.Format("Table {0}: trying to infer id generator from schema", tableMetaData.Name));
try{
var dt = GetCompleteColumnSchema(tableMetaData);
int isIdentity = dt.Columns.IndexOf(ISIDENTITY);
int colName = dt.Columns.IndexOf(COLNAME);
List <IColumnMetadata> cols = new List <IColumnMetadata>();
foreach (DataRow dr in dt.Rows)
{
if (string.Compare(dr.ItemArray[colName].ToString(), iColumnMetadata.Name, true) == 0)
{
if ((bool)dr.ItemArray[isIdentity])
{
return new generator()
{
@class = "native"
}
}
;
else
{
return new generator()
{
@class = "assigned"
}
};
}
}
}
catch (Exception e)
{
logger.Warn(string.Format("Table {0}: unable to infer id generator from schema. Please consider to use configuration to specify it.", tableMetaData.Name), e);
}
return(null);
}
private IPlanItem RebuildWithLatest(IPlanItem planHead, IColumnMetadata latestByColumn)
{
var column = Metadata.GetColumnByPropertyName(latestByColumn.PropertyName);
var intersc = planHead as IntersectPlanItem;
if (intersc != null)
{
if (AddLatestToColumnScan(intersc.Left, latestByColumn.PropertyName))
{
return
(new IntersectPlanItem(
RebuildWithLatest(intersc.Left, latestByColumn),
intersc.Right));
}
if (AddLatestToColumnScan(intersc.Right, latestByColumn.PropertyName))
{
return(new IntersectPlanItem(intersc.Left,
RebuildWithLatest(intersc.Right, latestByColumn)));
}
throw new InvalidOperationException("One of the Intersect path " +
"supposed to be reduced with" +
" Latest by symbol plan");
}
var union = planHead as UnionPlanItem;
if (union != null)
{
return(new UnionPlanItem(
RebuildWithLatest(union.Left, latestByColumn),
RebuildWithLatest(union.Right, latestByColumn)));
}
var scan = planHead as IColumnScanPlanItemCore;
if (scan != null)
{
if (scan.CanTranformLastestByIdPlanItem(latestByColumn))
{
scan.ApplyLastestByIdPlanItem(latestByColumn);
return(planHead);
}
}
var timestmp = planHead as TimestampRangePlanItem;
if (timestmp != null)
{
var newItem = CreateLastestByIdPlanItem(column);
newItem.Timestamps.Intersect(timestmp.Timestamps);
return(newItem);
}
throw new NotSupportedException("Plan type is not supported " + planHead.GetType());
}
public static bool CopyColumn(IColumnMetadata from, IColumnMetadata to)
{
var parent = to.TableMetadata;
if (!CopyProperties(from, to))
{
return(false);
}
to.TableMetadata = parent;
return(true);
}
public long GetCardinalityByColumnValue <T>(IReadTransactionContext tx, IColumnMetadata col, IList <T> values)
{
if (col.Indexed)
{
var part = _partitionManager.GetOpenPartitions().FirstOrDefault(p => p != null);
if (part != null)
{
return(values.Sum(value => part.GetSymbolRowCount(col.ColumnID, value, tx)));
}
}
return(_metadata.Settings.RecordHint / col.HintDistinctCount * values.Count);
}
public bool CanTranformLastestByIdPlanItem(IColumnMetadata column)
{
var partitionAsColumn = _partitionFilter as IColumnFilter;
if (_partitionFilter != null && partitionAsColumn == null)
{
var existingLatestFileter = _partitionFilter as ILatestBySymbolFilter;
return(existingLatestFileter != null && existingLatestFileter.Column.ColumnID == column.ColumnID);
}
return(true);
}
private static void CreateColumnScan <TT>(IColumnMetadata column, object literal, ResultSetBuilder builder)
{
if (literal == null)
{
builder.ColumnNullScan(column);
}
else
{
var value = (TT)column.ToTypedValue(literal);
builder.ColumnScan <TT>(column, value);
}
}
/// <summary>
/// constructor with column data
/// </summary>
/// <param name="column"></param>
public ColumnConfig(IColumnMetadata copy, string original)
{
//init properties
SystemTypes = BermudaConfigUtil.GetSystemTypes();
BoolValues = BermudaConfigUtil.GetBoolValues();
//init column
Column = copy;
ColumnOriginal = original;
//init gui
InitializeComponent();
}
private static void CreateColumnNotEqualScan <TT>(IColumnMetadata column, object literal, ResultSetBuilder builder)
{
if (literal == null)
{
builder.ColumnNotNullScan(column);
}
else
{
var value = (TT)column.ToTypedValue(literal);
var lambda = (Func <TT, bool>)(t => !object.Equals(t, value));
builder.ColumnLambdaScan(column, lambda);
}
}
private int SatisfyLen(IColumnMetadata cInfo, cfg.db2hbmconfSqltype candidate)
{
if (null == candidate.length)
return 0;
else
{
int hi, lo;
GetHiLo(candidate.length,out hi,out lo);
if (cInfo.ColumnSize >= lo && cInfo.ColumnSize <= hi)
return 1;
else
return 0;
}
}
/// <summary>
/// Adiciona uma coluna para a instancia.
/// </summary>
/// <param name="rs"></param>
private void AddColumn(System.Data.DataRow rs)
{
string column = GetColumnName(rs);
if (string.IsNullOrEmpty(column))
{
return;
}
if (GetColumnMetadata(column) == null)
{
IColumnMetadata info = GetColumnMetadata(rs);
_columns[info.Name.ToLowerInvariant()] = info;
}
}
private void AddColumn(DataRow rs)
{
string column = GetColumnName(rs);
if (string.IsNullOrEmpty(column))
{
return;
}
if (GetColumnMetadata(column) == null)
{
IColumnMetadata info = GetColumnMetadata(rs);
columns[info.Name] = info;
}
}
private static bool CompareType(IColumnMetadata columnInfo, Dialect dialect, Column column, IMapping mapping)
{
if (Convert.ToBoolean(columnInfo.Nullable) != column.IsNullable)
{
return(false);
}
var typeName = dialect.GetTypeName(column.GetSqlTypeCode(mapping));
typeName = typeName.Replace(" UNSIGNED", "");
if (typeName.Match("INTEGER"))
{
typeName = "int";
}
typeName = new Regex(@"\(\d+(\s*,\s*\d+)?\)$").Replace(typeName, "");
return(columnInfo.TypeName.Match(typeName));
}
public void ColumnNotNullScan(IColumnMetadata column)
{
var planItem = new RowScanPlanItem(_journal, _tx);
_planHead = planItem;
if (!Metadata.IsNullColumnID.HasValue || !column.Nullable || column.NullIndex < 0)
{
return;
}
var isNullColumn = Metadata.GetColumnByID(Metadata.IsNullColumnID.Value);
Func <ByteArray, bool> lambda = ba => !ba.IsSet(column.NullIndex);
planItem.AddLambdaScan(isNullColumn, lambda);
}
public string GetNHType(IColumnMetadata cInfo)
{
List<CandidateType> found = new List<CandidateType>();
var comp = config.typemapping.Where(t => string.Compare(t.dbtype, cInfo.TypeName, true) == 0);
foreach (var candidate in comp)
{
CandidateType ct = new CandidateType();
ct.Type = candidate.nhtype;
ct.SatisfiedRestrictions += SatisfyLen(cInfo, candidate);
ct.SatisfiedRestrictions += SatisfyPrecision(cInfo, candidate);
ct.SatisfiedRestrictions += SatisfyScale(cInfo, candidate);
found.Add(ct);
}
if (found.Count() > 0)
return found.OrderByDescending(t=>t.SatisfiedRestrictions).First().Type;
//logger.Warn(string.Format("No NHibernate type defined for dbtype:{0} len:{1}", cInfo.TypeName, cInfo.ColumnSize));
return null;
}
public SymbolFilter(IColumnMetadata column, IList <T> values)
: base(column)
{
if (values == null)
{
throw new ArgumentNullException("values");
}
_column = column;
if (values.Count == 1)
{
_value = values[0];
}
else
{
_values = values;
}
}
protected virtual generator GetGenerator(IColumnMetadata iColumnMetadata, ITableMetadata tableMetaData)
{
if (currentContext.TableExceptions.HasException(tableMetaData.Name, tableMetaData.Catalog, tableMetaData.Schema))
{
var exc = currentContext.TableExceptions.GetTableException(tableMetaData.Name, tableMetaData.Catalog, tableMetaData.Schema);
if (exc.primarykey != null && exc.primarykey.generator != null)
{
generator g = new generator();
g.@class = exc.primarykey.generator.@class;
if (null != exc.primarykey.generator.param)
{
List<param> parms = new List<param>();
foreach (var p in exc.primarykey.generator.param)
{
parms.Add(new param() { name = p.name, Text = new string[] { p.Value } });
}
g.param = parms.ToArray();
}
return g;
}
}
logger.Info(string.Format("Table {0}: trying to infer id generator from schema",tableMetaData.Name));
try{
var dt = GetCompleteColumnSchema(tableMetaData);
int isIdentity = dt.Columns.IndexOf(ISIDENTITY);
int colName = dt.Columns.IndexOf(COLNAME);
List<IColumnMetadata> cols = new List<IColumnMetadata>();
foreach (DataRow dr in dt.Rows)
{
if (string.Compare(dr.ItemArray[colName].ToString(),iColumnMetadata.Name,true) == 0)
{
if( (bool)dr.ItemArray[isIdentity] )
return new generator(){ @class="native" };
else
return new generator() { @class = "assigned" };
}
}
}
catch( Exception e)
{
logger.Warn(string.Format("Table {0}: unable to infer id generator from schema. Please consider to use configuration to specify it.", tableMetaData.Name),e);
}
return null;
}
/// <summary>
/// delete a column
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btDelete_Click(object sender, RoutedEventArgs e)
{
//get the selected item
if (lbColumns.SelectedItem == null)
{
return;
}
IColumnMetadata col = lbColumns.SelectedItem as IColumnMetadata;
//prompt to delete
if (MessageBox.Show("Are you sure you wish to delete the selected item.", "Delete Confirmation", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
{
return;
}
//remove the column
Table.ColumnsMetadata.Remove(col.ColumnName);
_Columns.Remove(col);
}
private int SatisfyLen(IColumnMetadata cInfo, cfg.db2hbmconfSqltype candidate)
{
if (null == candidate.length)
{
return(0);
}
else
{
int hi, lo;
GetHiLo(candidate.length, out hi, out lo);
if (cInfo.ColumnSize >= lo && cInfo.ColumnSize <= hi)
{
return(1);
}
else
{
return(0);
}
}
}
private int SatisfyPrecision(IColumnMetadata cInfo, cfg.db2hbmconfSqltype candidate)
{
if (null == candidate.precision)
{
return(0);
}
else
{
int hi, lo;
GetHiLo(candidate.length, out hi, out lo);
if (cInfo.NumericalPrecision >= lo && cInfo.NumericalPrecision <= hi)
{
return(1);
}
else
{
return(0);
}
}
}
public string GetNHType(IColumnMetadata cInfo)
{
List <CandidateType> found = new List <CandidateType>();
var comp = config.typemapping.Where(t => string.Compare(t.dbtype, cInfo.TypeName, true) == 0);
foreach (var candidate in comp)
{
CandidateType ct = new CandidateType();
ct.Type = candidate.nhtype;
ct.SatisfiedRestrictions += SatisfyLen(cInfo, candidate);
ct.SatisfiedRestrictions += SatisfyPrecision(cInfo, candidate);
ct.SatisfiedRestrictions += SatisfyScale(cInfo, candidate);
found.Add(ct);
}
if (found.Count() > 0)
{
return(found.OrderByDescending(t => t.SatisfiedRestrictions).First().Type);
}
//logger.Warn(string.Format("No NHibernate type defined for dbtype:{0} len:{1}", cInfo.TypeName, cInfo.ColumnSize));
return(null);
}
public bool ProcessColumn(IColumnMetadata ColumnMeta, string data, out object result)
{
try
{
// deal with nullable columns
if (nullableValues.ContainsKey(ColumnMeta.ColumnName) && nullableValues[ColumnMeta.ColumnName].Equals(data))
{
result = null;
}
else if (ColumnMeta.ColumnName.Equals("Id"))
{
var epochDays = (int)((DateTime)cachedColumns["Date"]).Subtract(new DateTime(1929, 1, 1)).TotalDays;
result = long.Parse(epochDays + (string)cachedColumns["Station"] + (string)cachedColumns["Wban"]);
}
else if (ColumnMeta.ColumnType.Equals(typeof(DateTime)))
{
result = new DateTime((int)cachedColumns["Year"],
(int)cachedColumns["Month"],
(int)cachedColumns["Day"]);
}
else if (ColumnMeta.ColumnType.Equals(typeof(bool)))
{
result = data.Equals("1");
}
else
{
result = Convert.ChangeType(data, ColumnMeta.ColumnType);
}
cachedColumns[ColumnMeta.ColumnName] = result;
return(true);
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex.ToString());
result = null;
return(false);
}
}
public bool ProcessColumn(IColumnMetadata ColumnMeta, string data, out object result)
{
try
{
// deal with nullable columns
if (nullableValues.ContainsKey(ColumnMeta.ColumnName) && nullableValues[ColumnMeta.ColumnName].Equals(data))
{
result = null;
}
else if (ColumnMeta.ColumnName.Equals("Id"))
{
var epochDays = (int)((DateTime)cachedColumns["Date"]).Subtract(new DateTime(1929, 1, 1)).TotalDays;
result = long.Parse(epochDays + (string)cachedColumns["Station"] + (string)cachedColumns["Wban"]);
}
else if (ColumnMeta.ColumnType.Equals(typeof(DateTime)))
{
result = new DateTime((int)cachedColumns["Year"],
(int)cachedColumns["Month"],
(int)cachedColumns["Day"]);
}
else if (ColumnMeta.ColumnType.Equals(typeof(bool)))
{
result = data.Equals("1");
}
else
{
result = Convert.ChangeType(data, ColumnMeta.ColumnType);
}
cachedColumns[ColumnMeta.ColumnName] = result;
return true;
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex.ToString());
result = null;
return false;
}
}
/// <summary>
/// handle double click on column for edit
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ListBoxItem_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
var item = sender as ListBoxItem;
if (item == null || !item.IsSelected)
{
return;
}
IColumnMetadata sel = item.Content as IColumnMetadata;
IColumnMetadata column = new ColumnMetadata(Table);
BermudaConfigUtil.CopyColumn(sel, column);
ColumnConfig window = new ColumnConfig(column, column.ColumnName);
var ret = window.ShowDialog();
if (!ret.HasValue || ret.Value == false)
{
return;
}
BermudaConfigUtil.CopyColumn(column, sel);
lbColumns.Items.Refresh();
}
protected override void OnProcess(GenerationContext context)
{
currentContext = context;
foreach (DataRow t in currentContext.FilteredTables)
{
IColumnMetadata[] keyColumns = new IColumnMetadata[0];
var tableMetaData = currentContext.Schema.GetTableMetadata(t, true);
string entityName = currentContext.NamingStrategy.GetEntityNameFromTableName(tableMetaData.Name);
keyColumns = GetKeyColumns(tableMetaData);
logger.Debug(string.Format("{0} working on:", GetType().Name) + tableMetaData.Name);
// remove key colums for standard properties
Array.ForEach(keyColumns, q => currentContext.Model.RemovePropertyByColumn(entityName, q.Name));
@class clazz = currentContext.Model.GetClassFromEntityName(entityName);
if (null == clazz)
{
logger.Warn(string.Format("Inconsistent meta model:entity {0} does not exists anymore", entityName));
}
else
{
clazz.Item = CreateId(keyColumns, tableMetaData);
}
}
}
private IList <T> ExtractColumnContains <T>(IColumnMetadata column)
{
var mainF = _partitionFilter as SymbolFilter <T>;
if (mainF != null && mainF.Column.ColumnID == column.ColumnID)
{
return(mainF.FilterValues);
}
if (_andFilters != null)
{
SymbolFilter <T> found = _andFilters
.OfType <SymbolFilter <T> >()
.FirstOrDefault(c => c.Column.ColumnID == column.ColumnID);
if (found != null)
{
_andFilters.Remove(found);
return(found.FilterValues);
}
}
return(null);
}
private int SatisfyScale(IColumnMetadata cInfo, cfg.db2hbmconfSqltype candidate)
{
return 0;
}
public void AddColumn(IColumnMetadata column)
{
if (column != null) columns.Add(column);
}
private int SatisfyPrecision(IColumnMetadata cInfo, cfg.db2hbmconfSqltype candidate)
{
if (null == candidate.precision)
return 0;
else
{
int hi, lo;
GetHiLo(candidate.length, out hi, out lo);
if (cInfo.NumericalPrecision >= lo && cInfo.NumericalPrecision <= hi)
return 1;
else
return 0;
}
}
/// <summary>
/// constructor with column data
/// </summary>
/// <param name="column"></param>
public ColumnConfig(IColumnMetadata copy, string original)
{
//init properties
SystemTypes = BermudaConfigUtil.GetSystemTypes();
BoolValues = BermudaConfigUtil.GetBoolValues();
//init column
Column = copy;
ColumnOriginal = original;
//init gui
InitializeComponent();
}
public ITableWriter Column(IColumnMetadata column)
{
var col = _table.Columns.Add(column.Name, column.DataType);
if (!string.IsNullOrEmpty(column.Label)) col.Caption = column.Label;
return this;
}
protected override void OnProcess(GenerationContext context)
{
currentContext = context;
foreach (DataRow t in currentContext.FilteredTables)
{
IColumnMetadata[] keyColumns = new IColumnMetadata[0];
var tableMetaData = currentContext.Schema.GetTableMetadata(t, true);
string entityName = currentContext.NamingStrategy.GetEntityNameFromTableName(tableMetaData.Name);
keyColumns = GetKeyColumns(tableMetaData);
logger.Debug(string.Format("{0} working on:",GetType().Name )+ tableMetaData.Name);
// remove key colums for standard properties
Array.ForEach(keyColumns, q => currentContext.Model.RemovePropertyByColumn(entityName, q.Name));
@class clazz = currentContext.Model.GetClassFromEntityName(entityName);
if (null == clazz)
{
logger.Warn(string.Format("Inconsistent meta model:entity {0} does not exists anymore",entityName));
}
else
{
clazz.Item = CreateId(keyColumns,tableMetaData);
}
}
}
public static bool CopyColumn(IColumnMetadata from, IColumnMetadata to)
{
var parent = to.TableMetadata;
if (!CopyProperties(from, to)) return false;
to.TableMetadata = parent;
return true;
}
public ITableWriter Column(IColumnMetadata column)
{
this.Column(new Column(column.Name) { Label = column.Label, DataType = column.DataType });
return this;
}
