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>>(); }