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)));
}
}
}
}
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);
}
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 void AddProperties(@class clazz,string entity, ITableMetadata tableMetaData)
{
var columnSet = currentContext.Schema.GetColumns(tableMetaData.Catalog, tableMetaData.Schema, tableMetaData.Name, null);
int nameOrdinal = columnSet.Columns.IndexOf(COLUMN_NAME);
int typeOrdinal = columnSet.Columns.IndexOf(DATA_TYPE);
foreach (DataRow row in columnSet.Rows)
{
var cInfo = tableMetaData.GetColumnMetadata(row.ItemArray[nameOrdinal].ToString());
property p = currentContext.Model.AddPropertyToEntity(entity
,currentContext.NamingStrategy.GetPropertyNameFromColumnName(cInfo.Name));
p.notnull = !true.ParseFromDb(cInfo.Nullable);
p.notnullSpecified = !true.ParseFromDb(cInfo.Nullable);
p.column = 0 == string.Compare(p.name,cInfo.Name,true)?null:cInfo.Name;
p.type1 = typeConverter.GetNHType(cInfo);
if (p.type1 == null)
{
logger.Warn(string.Format("No NHibernate type defined for dbtype:{0} len:{1}", cInfo.TypeName, cInfo.ColumnSize));
}
if (cInfo.ColumnSize > 0)
{
p.length = cInfo.ColumnSize.ToString();
}
if (cInfo.NumericalPrecision > 0)
{
p.precision = cInfo.NumericalPrecision.ToString();
}
}
}
/// <summary>
/// copy table
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btCopyTable_Click(object sender, RoutedEventArgs e)
{
//get the selected item
if (lbTables.SelectedItem == null)
{
return;
}
ITableMetadata copy = lbTables.SelectedItem as ITableMetadata;
//create the new item
ITableMetadata table = new TableMetadata(Catalog.CatalogMetadata);
BermudaConfigUtil.CopyTable(copy, table);
//open the window
TableConfig window = new TableConfig(table, "");
var ret = window.ShowDialog();
if (!ret.HasValue || ret == false)
{
return;
}
//add to list
Tables.Add(table);
Catalog.CatalogMetadata.Tables.Add(table.TableName, table);
}
private void AddProperties(@class clazz, string entity, ITableMetadata tableMetaData)
{
var columnSet = currentContext.Schema.GetColumns(tableMetaData.Catalog, tableMetaData.Schema, tableMetaData.Name, null);
int nameOrdinal = columnSet.Columns.IndexOf(COLUMN_NAME);
int typeOrdinal = columnSet.Columns.IndexOf(DATA_TYPE);
foreach (DataRow row in columnSet.Rows)
{
var cInfo = tableMetaData.GetColumnMetadata(row.ItemArray[nameOrdinal].ToString());
property p = currentContext.Model.AddPropertyToEntity(entity
, currentContext.NamingStrategy.GetPropertyNameFromColumnName(cInfo.Name));
p.notnull = !true.ParseFromDb(cInfo.Nullable);
p.notnullSpecified = !true.ParseFromDb(cInfo.Nullable);
p.column = 0 == string.Compare(p.name, cInfo.Name, true)?null:cInfo.Name;
p.type1 = typeConverter.GetNHType(cInfo);
if (p.type1 == null)
{
logger.Warn(string.Format("No NHibernate type defined for dbtype:{0} len:{1}", cInfo.TypeName, cInfo.ColumnSize));
}
if (cInfo.ColumnSize > 0)
{
p.length = cInfo.ColumnSize.ToString();
}
if (cInfo.NumericalPrecision > 0)
{
p.precision = cInfo.NumericalPrecision.ToString();
}
}
}
/// <summary>
/// constructor with table
/// </summary>
public TableConfig(ITableMetadata copy, string original)
{
//init properties
SystemTypes = BermudaConfigUtil.GetSystemTypes();
Comparators = BermudaConfigUtil.GetComparators();
PurgeOperations = BermudaConfigUtil.GetPurgeOperations();
BoolValues = BermudaConfigUtil.GetBoolValues();
//get the table
Table = copy;
TableOriginal = original;
//init the column collection
_Columns = new ObservableCollection <IColumnMetadata>();
Table.ColumnsMetadata.Values.ToList().ForEach(c => _Columns.Add(c));
int position = 0;
_Columns.OrderBy(c => c.OrdinalPosition).ToList().ForEach(c => c.OrdinalPosition = position++);
Columns = new CollectionViewSource()
{
Source = _Columns
};
Columns.SortDescriptions.Add(new System.ComponentModel.SortDescription("OrdinalPosition", System.ComponentModel.ListSortDirection.Ascending));
//init gui
InitializeComponent();
}
public string GetColumnName(ITableMetadata metadata)
{
TableAttribute table = metadata.Relation.Parent?.Annotations?.FirstOfType <TableAttribute>();
ColumnAttribute column = metadata.Relation.Annotations?.FirstOfType <ColumnAttribute>();
if (column != null && string.IsNullOrWhiteSpace(column.Name))
{
return(this.GetDefaultColumnName(metadata));
}
else if (column != null)
{
return(column.Name);
}
else if (table != null)
{
Type declaringType = this.GetDeclaringTypeOfAttribute(metadata.Relation.Parent.Type, table);
if (declaringType == metadata.Relation.Member?.DeclaringType)
{
return(this.GetDefaultColumnName(metadata));
}
}
return(null);
}
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());
}
public void Build(IDbDataParameter adoParameter)
{
SqlParameter sqlParam = adoParameter as SqlParameter ?? throw new InvalidOperationException("Table-valued parameters are only supported on SqlParameter instances.");
sqlParam.ParameterName = this.Name;
Action <SqlParameter, IRelation> binder = TvpCache.Binders.GetOrAdd(this.Relation.Identity, key =>
{
ITableMetadata[] columnMetadata = key.Heading.Select(m => m.GetMetadata <ITableMetadata>()).Where(m => m.HasFlag(TableMetadataFlags.Column)).ToArray();
IBindingMetadata[] bindingMetadata = columnMetadata.Select(m => m.Identity.GetMetadata <IBindingMetadata>()).ToArray();
if (bindingMetadata.Length == 0)
{
throw new InvalidOperationException("No columns found.");
}
ITableMetadata tableMetadata = columnMetadata[0].HasFlag(TableMetadataFlags.Table) ? columnMetadata[0] : columnMetadata[0].MemberOf;
string tvpName = string.Join(".", tableMetadata.TableName);
string[] columnNames = columnMetadata.Select(m => m.ColumnName).ToArray();
BindingParameterConverter[] converters = bindingMetadata.Select(m => m?.Parameter?.Convert).ToArray();
return((sp, r) => BindParameter(sp, tvpName, columnNames, converters, r));
});
binder(sqlParam, this.Relation);
}
public ITableMetadata GetTableMetaData(string catalog, string schema, string name)
{
ITableMetadata res = null;
tableMetaData.TryGetValue(GetKey(catalog, schema, name), out res);
return(res);
}
internal bool Match(ITableMetadata meta)
{
return((null == catalogRx || catalogRx.IsProperMatch(meta.Catalog ?? ""))
&&
(null == schemaRx || schemaRx.IsProperMatch(meta.Schema ?? ""))
&&
(null == tableRx || tableRx.IsProperMatch(meta.Name ?? "")));
}
/// <summary>
/// Appends the current column name in unqualified form, e.g. <c>"MyColumn"</c>, to the attribute buffer.
/// </summary>
/// <param name="attribute">The current attribute.</param>
/// <returns>A new attribute containing the appended buffer.</returns>
public static IProjectionAttribute ColName(this IProjectionAttribute attribute)
{
ITableMetadata column = ProjectionHelper.GetPreferredColumnMetadata(attribute);
string identifier = attribute.Context.Domain.Dialect.Identifier(column.ColumnName);
return(attribute.Append(identifier));
}
/// <summary>
/// Appends the current table alias, e.g. <c>T0</c>, to the attribute buffer.
/// </summary>
/// <param name="attribute">The current attribute.</param>
/// <returns>A new attribute containing the appended buffer.</returns>
public static IProjectionAttribute Ali(this IProjectionAttribute attribute)
{
ITableMetadata table = ProjectionHelper.GetTableMetadata(attribute);
string alias = attribute.Context.Lookup.Table(attribute.Identity, table.Identity);
return(attribute.Append(alias));
}
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);
}
public void StoreTableMetaData(string catalog, string schema, string name, ITableMetadata metas)
{
tableMetaData[GetKey(catalog, schema, name)] = metas;
if (!tableMetadataByName.ContainsKey(name))
{
tableMetadataByName[name] = new List <ITableMetadata>();
}
tableMetadataByName[name].Add(metas);
}
/// <summary>
/// Appends the current table name, e.g. <c>"MyTable"</c>, to the attribute buffer.
/// </summary>
/// <param name="attribute">The current attribute.</param>
/// <returns>A new attribute containing the appended buffer.</returns>
public static IProjectionAttribute TblName(this IProjectionAttribute attribute)
{
ITableMetadata table = ProjectionHelper.GetTableMetadata(attribute);
string qualifier = attribute.Context.Domain.Dialect.Qualifier;
string tableName = string.Join(qualifier, table.TableName.Select(attribute.Context.Domain.Dialect.Identifier));
return(attribute.Append(tableName));
}
private void CreateTableMetadata(ProjectionMetadata metadata)
{
ITableMetadata table = metadata.Identity.Lookup <ITableMetadata>();
if (table != null)
{
metadata.Table = table.HasFlag(TableMetadataFlags.Table) ? table : table.Owner;
metadata.Column = table.HasFlag(TableMetadataFlags.Column) ? table : null;
}
}
public string GetColumnName(ITableMetadata metadata)
{
IProperty property = this.FindProperty(metadata.Relation);
if (property != null && metadata.Relation.Member != null && metadata.Relation.Member.DeclaringType.IsAssignableFrom(property.DeclaringType.ClrType))
{
return(this.GetColumnName(property));
}
return(null);
}
public string[] GetTableName(ITableMetadata metadata)
{
IEntityType entity = this.entities.FirstOrDefault(e => e.ClrType.IsAssignableFrom(metadata.Relation.Type));
string schemaName = this.GetSchemaName(entity);
string tableName = this.GetTableName(entity);
if (tableName == null)
{
return(null);
}
return(new[] { schemaName, tableName }.NotNull().ToArray());
}
protected DataTable GetCompleteColumnSchema(ITableMetadata tableMetaData)
{
string key = string.Format("COLUMN.SCHEMA.{0}.{1}.{2}", tableMetaData.Catalog, tableMetaData.Schema, tableMetaData.Name);
if (null == currentContext[key])
{
DataTable dt = currentContext.Dialect.GetCompleteColumnSchema(currentContext.Connection, tableMetaData.Schema, tableMetaData.Name);
currentContext[key] = dt;
return(dt);
}
else
{
return(currentContext[key] as DataTable);
}
}
private ITableMetadata GetMetadata(IMetadataBuilderContext context, IRelationMetadata relation)
{
ITableMetadata parent = context.GetMetadata <ITableMetadata>(relation.Parent.Identity.Name) ?? this.GetMetadata(context, relation.Parent);
if (parent == null)
{
return(null);
}
else if (parent.Item != null && parent.Item.Identity.Equals(relation.Identity))
{
return(parent.Item);
}
return(parent.Properties.FirstOrDefault(m => m.Identity.Equals(relation.Identity)));
}
private ITableMetadata GetPrimaryTable(IForeignKeyColumnInfo[] iForeignKeyColumnInfo)
{
//we should have only one table as primary
ITableMetadata pname = null;
foreach (var s in iForeignKeyColumnInfo)
{
if (pname != null && s.PrimaryKeyTableName != pname.Name)
{
logger.Warn(string.Format("Inconsistent key definition. Set not created"));
return(null);
}
pname = new TableMetadata(s.PrimaryKeyTableCatalog, s.PrimaryKeyTableSchema, s.PrimaryKeyTableName);
}
return(pname);
}
/// <summary>
/// the constructor with parent and table definition
/// </summary>
/// <param name="bucket"></param>
public ReferenceDataTable(ICatalog catalog, ITableMetadata table_metadata)
:base(table_metadata)
{
Catalog = catalog;
Saturating = false;
Saturated = false;
LastSaturation = DateTime.UtcNow.AddDays(-1);
if (table_metadata.SaturationUpdateType == null)
LastUpdateValue = null;
else if (table_metadata.SaturationUpdateType == typeof(DateTime))
LastUpdateValue = new DateTime(1970, 1, 1);
else if (table_metadata.SaturationUpdateType == typeof(string))
LastUpdateValue = "";
else
LastUpdateValue = Convert.ChangeType(0, table_metadata.SaturationUpdateType);
}
public DataTable(ITableMetadata table_metadata)
{
TableMetadata = table_metadata;
//create the concurrent dictionary with the actual type
var type = typeof(ConcurrentDictionary<,>);
Type[] type_args = {typeof(Int64), table_metadata.DataType};
var constructed_type = type.MakeGenericType(type_args);
DataItems = (IDictionary)Activator.CreateInstance(constructed_type);
//caches for reflection
AddOrUpdateDelegateCache = new ConcurrentDictionary<Type, Delegate>();
AddOrUpdateMethodCache = new ConcurrentDictionary<Type, MethodInfo>();
TryGetValueMethodCache = new ConcurrentDictionary<Type, MethodInfo>();
TryRemoveMethodCache = new ConcurrentDictionary<Type, MethodInfo>();
}
public static IBindingParameterContract GetParameterContract(IBindingMetadata[] bindings)
{
ITableMetadata[] columns = bindings.Select(m => m.Identity.GetMetadata <ITableMetadata>()).ToArray();
ITableMetadata table = columns[0].HasFlag(TableMetadataFlags.Table) ? columns[0] : columns[0].MemberOf;
string tvpName = string.Join(".", table.TableName);
string[] columnNames = columns.Select(m => m.ColumnName).ToArray();
MetadataIdentity[] heading = bindings.Select(m => m.Identity).ToArray();
BindingParameterConverter[] converters = bindings.Select(m => m?.Parameter?.Convert).ToArray();
return(new BindingParameterContract()
{
Write = pi => GetParameterWriterProxy(tvpName, columnNames, heading, converters, pi),
});
}
public bool OpenFile(object FileObject, ITableMetadata TableMeta)
{
//throw new NotImplementedException();
var fileName = (S3Object)FileObject;
AmazonS3 s3 = AWSClientFactory.CreateAmazonS3Client();
var gor = new GetObjectRequest().WithBucketName(fileName.BucketName).WithKey(fileName.Key);
var file = s3.GetObject(gor);
string text = "";
using (var ms = new MemoryStream())
{
System.Diagnostics.Trace.WriteLine("Started reading file");
file.ResponseStream.CopyTo(ms); //actually fetches the file from S3
System.Diagnostics.Trace.WriteLine("Finished reading file");
using (var gzipStream = new GZipStream(new MemoryStream(ms.ToArray()), CompressionMode.Decompress))
{
System.Diagnostics.Trace.WriteLine("Decompressing file");
const int size = 4096;
byte[] buffer = new byte[size];
using (MemoryStream memory = new MemoryStream())
{
int count = 0;
do
{
count = gzipStream.Read(buffer, 0, size);
if (count > 0)
{
memory.Write(buffer, 0, count);
}
}
while (count > 0);
var memArray = memory.ToArray();
text = ASCIIEncoding.ASCII.GetString(memArray);
}
System.Diagnostics.Trace.WriteLine("Finished decompressing file");
}
}
Lines = text.Split(TableMeta.ColumnDelimiters, StringSplitOptions.RemoveEmptyEntries);
System.Diagnostics.Trace.WriteLine("Finished reading file");
lineCount = -1;
return true;
}
public static bool CopyTable(ITableMetadata from, ITableMetadata to)
{
var parent = to.CatalogMetadata;
if (!CopyProperties(from, to))
{
return(false);
}
to.CatalogMetadata = parent;
to.ColumnsMetadata = new Dictionary <string, IColumnMetadata>();
from.ColumnsMetadata.Values.ToList().ForEach(c =>
{
IColumnMetadata col = new ColumnMetadata(to);
CopyColumn(c, col);
to.ColumnsMetadata.Add(col.ColumnName, col);
});
return(true);
}
public DataTable(ITableMetadata table_metadata)
{
TableMetadata = table_metadata;
//create the concurrent dictionary with the actual type
var type = typeof(ConcurrentDictionary <,>);
Type[] type_args = { typeof(Int64), table_metadata.DataType };
var constructed_type = type.MakeGenericType(type_args);
DataItems = (IDictionary)Activator.CreateInstance(constructed_type);
//caches for reflection
AddOrUpdateDelegateCache = new ConcurrentDictionary <Type, Delegate>();
AddOrUpdateMethodCache = new ConcurrentDictionary <Type, MethodInfo>();
TryGetValueMethodCache = new ConcurrentDictionary <Type, MethodInfo>();
TryRemoveMethodCache = new ConcurrentDictionary <Type, MethodInfo>();
}
public void Build(IDbDataParameter adoParameter)
{
SqlParameter tableParam = adoParameter as SqlParameter ?? throw new InvalidOperationException("Table-valued parameters are only supported on SqlParameter instances.");
tableParam.ParameterName = this.Name;
Action <SqlParameter, IRelation> binder = TvpCache.Binders.GetOrAdd(this.Relation.Header, key =>
{
GetHeadingMetadata(key, out IBindingMetadata[] bindingMetadata, out ITableMetadata[] columnMetadata);
ITableMetadata tableMetadata = columnMetadata[0].HasFlag(TableMetadataFlags.Table) ? columnMetadata[0] : columnMetadata[0].Owner;
string tvpName = string.Join(".", tableMetadata.TableName);
string[] columnNames = columnMetadata.Select(m => m.ColumnName).ToArray();
BindingParameterConverter[] converters = bindingMetadata.Select(m => m?.Parameter?.Convert).ToArray();
return((sp, r) => BindParameter(sp, tvpName, columnNames, converters, bindingMetadata, r));
});
public bool OpenFile(object FileObject, ITableMetadata TableMeta)
{
//throw new NotImplementedException();
var fileName = (S3Object)FileObject;
AmazonS3 s3 = AWSClientFactory.CreateAmazonS3Client();
var gor = new GetObjectRequest().WithBucketName(fileName.BucketName).WithKey(fileName.Key);
var file = s3.GetObject(gor);
string text = "";
using (var ms = new MemoryStream())
{
System.Diagnostics.Trace.WriteLine("Started reading file");
file.ResponseStream.CopyTo(ms); //actually fetches the file from S3
System.Diagnostics.Trace.WriteLine("Finished reading file");
using (var gzipStream = new GZipStream(new MemoryStream(ms.ToArray()), CompressionMode.Decompress))
{
System.Diagnostics.Trace.WriteLine("Decompressing file");
const int size = 4096;
byte[] buffer = new byte[size];
using (MemoryStream memory = new MemoryStream())
{
int count = 0;
do
{
count = gzipStream.Read(buffer, 0, size);
if (count > 0)
{
memory.Write(buffer, 0, count);
}
}while (count > 0);
var memArray = memory.ToArray();
text = ASCIIEncoding.ASCII.GetString(memArray);
}
System.Diagnostics.Trace.WriteLine("Finished decompressing file");
}
}
Lines = text.Split(TableMeta.ColumnDelimiters, StringSplitOptions.RemoveEmptyEntries);
System.Diagnostics.Trace.WriteLine("Finished reading file");
lineCount = -1;
return(true);
}
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>
/// populate the columns collection based on selection change
/// </summary>
/// <param name="columns"></param>
/// <param name="e"></param>
private void PopulateColumns(ObservableCollection <string> columns, SelectionChangedEventArgs e)
{
//init the columns
columns.Clear();
//validate the selection
if (e.AddedItems.Count == 0)
{
return;
}
//get the table
string name = e.AddedItems[0].ToString();
//get the metadata for table
ITableMetadata table = Relationship.CatalogMetadata.Tables[name];
table.ColumnsMetadata.Values.ToList().ForEach(c => columns.Add(c.FieldMapping));
}
/// <summary>
/// delete table
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btDeleteTable_Click(object sender, RoutedEventArgs e)
{
//get the selected item
if (lbTables.SelectedItem == null)
{
return;
}
ITableMetadata table = lbTables.SelectedItem as ITableMetadata;
//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 item
Catalog.CatalogMetadata.Tables.Remove(table.TableName);
Tables.Remove(table);
}
public string[] GetTableName(ITableMetadata metadata)
{
TableAttribute table = metadata.Relation.Annotations?.FirstOfType <TableAttribute>();
if (table != null)
{
string[] tableName = table.Parts?.Where(p => !string.IsNullOrWhiteSpace(p)).ToArray();
if (tableName == null || tableName.Length == 0)
{
Type declaringType = this.GetDeclaringTypeOfAttribute(metadata.Relation.Type, table);
return(new[] { declaringType?.Name ?? metadata.Relation.Type.Name });
}
return(tableName);
}
return(null);
}
private static ITableMetadata GetPreferredTableMetadata(IProjectionMetadata metadata)
{
ITableMetadata table = metadata.Table;
ITableMetadata item = metadata.Item?.Table;
if (table != null && table.HasFlag(TableMetadataFlags.Table))
{
return(table);
}
else if (table?.MemberOf != null && table.MemberOf.HasFlag(TableMetadataFlags.Table))
{
return(table.MemberOf);
}
else if (item != null && item.HasFlag(TableMetadataFlags.Table))
{
return(item);
}
return(null);
}
public bool OpenFile(object FileObject, ITableMetadata TableMeta)
{
try
{
reader = new StreamReader((string)FileObject);
lineCount = -1;
currentLine = null;
// advance past header rows
while (TableMeta.HeaderRowCount > (lineCount + 1))
{
lineCount++;
currentLine = reader.ReadLine();
}
return true;
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex);
return false;
}
}
/// <summary>
/// the constructor with parent
/// </summary>
/// <param name="table_metadata"></param>
public ColumnMetadata(ITableMetadata table_metadata)
{
Init(table_metadata);
}
/// <summary>
/// init the column
/// </summary>
/// <param name="table_metadata"></param>
public void Init(ITableMetadata table_metadata)
{
TableMetadata = table_metadata;
}
/// <summary>
/// the constructor with parent and table definition
/// </summary>
/// <param name="bucket"></param>
public BucketDataTable(IBucket bucket, ITableMetadata table_metadata)
:base(bucket.Catalog, table_metadata)
{
Bucket = bucket;
LastSaturation = default(DateTime);
}
public CatalogDataTable(ICatalog catalog, ITableMetadata table_metadata)
: base(table_metadata)
{
Catalog = catalog;
}
public ConfiguredForeignKeyColumnInfo(cfg.db2hbmconfTableForeignkeyColumnref cref, cfg.db2hbmconfTableForeignkey fk, ITableMetadata metaData)
{
PrimaryKeyTableName = fk.foreigntable;
PrimaryKeyTableCatalog = fk.foreigncatalog;
PrimaryKeyTableSchema = fk.foreignschema;
PrimaryKeyColumnName = cref.foreigncolumn;
ForeignKeyColumnName = cref.localcolumn;
ForeignKeyTableCatalog = metaData.Catalog;
ForeignKeyTableSchema = metaData.Schema;
ForeignKeyTableSchema = metaData.Name;
}
private IForeignKeyColumnInfo[] GetColumnInfoFromConfig(cfg.db2hbmconfTableForeignkey fk, ITableMetadata metaData)
{
List<IForeignKeyColumnInfo> fks = new List<IForeignKeyColumnInfo>();
foreach (var ci in fk.columnref)
{
fks.Add(new ConfiguredForeignKeyColumnInfo(ci, fk, metaData));
}
return fks.ToArray();
}
protected DataTable GetCompleteColumnSchema(ITableMetadata tableMetaData)
{
string key = string.Format("COLUMN.SCHEMA.{0}.{1}.{2}", tableMetaData.Catalog, tableMetaData.Schema, tableMetaData.Name);
if (null == currentContext[key])
{
DataTable dt = currentContext.Dialect.GetCompleteColumnSchema(currentContext.Connection, tableMetaData.Schema, tableMetaData.Name);
currentContext[key] = dt;
return dt;
}
else
{
return currentContext[key] as DataTable;
}
}
public static bool CopyTable(ITableMetadata from, ITableMetadata to)
{
var parent = to.CatalogMetadata;
if (!CopyProperties(from, to)) return false;
to.CatalogMetadata = parent;
to.ColumnsMetadata = new Dictionary<string, IColumnMetadata>();
from.ColumnsMetadata.Values.ToList().ForEach(c =>
{
IColumnMetadata col = new ColumnMetadata(to);
CopyColumn(c, col);
to.ColumnsMetadata.Add(col.ColumnName, col);
});
return true;
}
public string Translate(
Restrictions restrictions,
Dictionary<string, object> parameters,
ITableMetadata tableMetadata)
{
var builder = new StringBuilder();
builder.AppendFormat("SELECT body FROM public.{0}", tableMetadata.Name);
var first = true;
foreach (var item in restrictions.Filters)
{
builder.AppendLine();
builder.AppendFormat("{0} {1}",
first ? "WHERE " : "AND ",
GetFilter(item, parameters));
if (first)
{
first = false;
}
}
if (!String.IsNullOrWhiteSpace(restrictions.SortClause.FieldName))
{
builder.AppendLine();
var sortClause = String.Empty;
switch (restrictions.SortClause.SortType)
{
case SortType.Undefined:
//do nothing
break;
case SortType.Date:
sortClause = "ORDER BY CAST(CAST(body->'{0}' as TEXT) as DATE) {1}";
break;
case SortType.Number:
//TODO: replace fixed number size with more dynamic.
sortClause = "ORDER BY to_number((body->'{0}')::TEXT, '9999999999999999') {1}";
break;
default:
//Text will always be the default conversion
sortClause = "ORDER BY (body->'{0}')::TEXT {1}";
break;
}
builder.AppendFormat(sortClause, restrictions.SortClause.FieldName,
restrictions.SortClause.SortOrder == SortOrder.Ascending ? "" : "DESC");
}
if (restrictions.Take > 0)
{
builder.AppendLine();
builder.AppendFormat("LIMIT {0}", restrictions.Take);
}
if (restrictions.Skip > 0)
{
builder.AppendLine();
builder.AppendFormat("OFFSET {0}", restrictions.Skip);
}
builder.Append(";");
return builder.ToString();
}
public void StoreTableMetaData(string catalog, string schema, string name, ITableMetadata metas)
{
tableMetaData[GetKey(catalog, schema, name)] = metas;
if (!tableMetadataByName.ContainsKey(name))
tableMetadataByName[name] = new List<ITableMetadata>();
tableMetadataByName[name].Add(metas);
}
/// <summary>
/// constructor with table
/// </summary>
public TableConfig(ITableMetadata copy, string original)
{
//init properties
SystemTypes = BermudaConfigUtil.GetSystemTypes();
Comparators = BermudaConfigUtil.GetComparators();
PurgeOperations = BermudaConfigUtil.GetPurgeOperations();
BoolValues = BermudaConfigUtil.GetBoolValues();
//get the table
Table = copy;
TableOriginal = original;
//init the column collection
_Columns = new ObservableCollection<IColumnMetadata>();
Table.ColumnsMetadata.Values.ToList().ForEach(c => _Columns.Add(c));
int position = 0;
_Columns.OrderBy(c => c.OrdinalPosition).ToList().ForEach(c => c.OrdinalPosition = position++);
Columns = new CollectionViewSource() { Source = _Columns };
Columns.SortDescriptions.Add(new System.ComponentModel.SortDescription("OrdinalPosition", System.ComponentModel.ListSortDirection.Ascending));
//init gui
InitializeComponent();
}
/// <summary>
/// constructor with parent info
/// </summary>
/// <param name="bucket"></param>
/// <param name="table_metadata"></param>
/// <param name="relationship_metadata"></param>
public RelationshipDataTable(IBucket bucket, ITableMetadata table_metadata, IRelationshipMetadata relationship_metadata)
: base(bucket, table_metadata)
{
RelationshipMetadata = relationship_metadata;
RelationshipParentLookup = new ConcurrentDictionary<long, ConcurrentDictionary<long, long>>();
}
