public ColumnReference(TableReference tableReference, Column columnDescription) { InitializeMembers(); this.tableReference = tableReference; this.columnName = columnDescription.Name; this.dataType = columnDescription.DataType; }
/// <summary> /// Copies member variables /// </summary> /// <param name="old"></param> private void CopyMembers(Column old) { this.isNullable = old.isNullable; this.isIdentity = old.isIdentity; this.isKey = old.isKey; this.isHidden = old.isHidden; }
/// <summary> /// Copy constructor /// </summary> /// <param name="old"></param> public Column(Column old) { CopyMembers(old); }
public static Column Create(DataRow dr) { var column = new Column(); column.CopyFromSchemaTableRow(dr); return column; }
public bool Compare(Column other, bool observeColumnOrder) { var res = true; res &= observeColumnOrder || (this.ID == other.ID); res &= SchemaManager.Comparer.Compare(this.Name, other.Name) == 0; res &= this.DataType.Compare(other.DataType); return res; }
private void AddSchemaTableColumn(DataTable dt, Column col, int ordinal) { var dr = dt.NewRow(); dr[SchemaTableColumn.ColumnName] = col.Name; dr[SchemaTableColumn.ColumnOrdinal] = ordinal; dr[SchemaTableColumn.ColumnSize] = col.DataType.Length; dr[SchemaTableColumn.NumericPrecision] = col.DataType.Precision; dr[SchemaTableColumn.NumericScale] = col.DataType.Scale; dr[SchemaTableColumn.IsUnique] = col.IsIdentity; dr[SchemaTableColumn.IsKey] = col.IsIdentity; dr[SchemaTableColumn.DataType] = col.DataType.Type; dr["DataTypeName"] = col.DataType.Name; dr[SchemaTableColumn.AllowDBNull] = col.DataType.IsNullable; dr[SchemaTableColumn.ProviderType] = col.DataType.Name; dr[SchemaTableColumn.IsAliased] = false; dr[SchemaTableColumn.IsExpression] = false; //dr[SchemaTableOptionalColumn.IsIdentity] = col.IsIdentity; dr[SchemaTableOptionalColumn.IsAutoIncrement] = col.IsIdentity; dr[SchemaTableOptionalColumn.IsRowVersion] = false; dr[SchemaTableOptionalColumn.IsHidden] = false; dr[SchemaTableColumn.IsLong] = col.DataType.IsMaxLength; dr[SchemaTableOptionalColumn.IsReadOnly] = true; dr[SchemaTableOptionalColumn.ProviderSpecificDataType] = col.DataType.Name; dt.Rows.Add(dr); }
private void RenderTable(TextWriter writer, IDataReader dr) { var schemaTable = dr.GetSchemaTable(); writer.WriteLine("<table border=\"1\" cellspacing=\"0\" style=\"border-collapse:collapse\">"); // header writer.WriteLine("<tr>"); for (int i = 0; i < dr.FieldCount; i++) { var column = new Column(); column.CopyFromSchemaTableRow(schemaTable.Rows[i]); writer.WriteLine("<td class=\"header\" nowrap>{0}<br />{1}</td>", column.Name, column.DataType.NameWithLength); } writer.WriteLine("</tr>"); // Rows while (dr.Read()) { writer.WriteLine("<tr>"); for (int i = 0; i < dr.FieldCount; i++) { writer.WriteLine("<td nowrap>{0}</td>", dr.GetValue(i).ToString()); } writer.WriteLine("</tr>"); } // Footer writer.WriteLine("</table>"); }
private ParserDelegate GetParserDelegate(Column column) { var t = column.DataType.Type; if (t == typeof(SByte)) { return delegate(string s, out object p) { SByte v; var r = SByte.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Int16)) { return delegate(string s, out object p) { Int16 v; var r = Int16.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Int32)) { return delegate(string s, out object p) { Int32 v; var r = Int32.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Int64)) { return delegate(string s, out object p) { Int64 v; var r = Int64.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Byte)) { return delegate(string s, out object p) { Byte v; var r = Byte.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(UInt16)) { return delegate(string s, out object p) { UInt16 v; var r = UInt16.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(UInt32)) { return delegate(string s, out object p) { UInt32 v; var r = UInt32.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(UInt64)) { return delegate(string s, out object p) { UInt64 v; var r = UInt64.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Boolean)) { // *** TODO: parse numbers! return delegate(string s, out object p) { bool v; var r = bool.TryParse(s, out v); p = v; return r; }; } else if (t == typeof(Single)) { return delegate(string s, out object p) { float v; var r = float.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Double)) { return delegate(string s, out object p) { double v; var r = double.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Decimal)) { return delegate(string s, out object p) { decimal v; var r = decimal.TryParse(s, File.NumberStyle, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Char)) { return delegate(string s, out object p) { if (s.Length == 1) { p = s[0]; return true; } else { p = null; return false; } }; } else if (t == typeof(String)) { return delegate(string s, out object p) { p = s; return true; }; } else if (t == typeof(DateTime)) { return delegate(string s, out object p) { DateTime v; var r = DateTime.TryParse(s, File.Culture, File.DateTimeStyle, out v); p = v; return r; }; } else if (t == typeof(DateTimeOffset)) { return delegate(string s, out object p) { DateTimeOffset v; var r = DateTimeOffset.TryParse(s, File.Culture, File.DateTimeStyle, out v); p = v; return r; }; } else if (t == typeof(TimeSpan)) { return delegate(string s, out object p) { TimeSpan v; var r = TimeSpan.TryParse(s, File.Culture, out v); p = v; return r; }; } else if (t == typeof(Guid)) { return delegate(string s, out object p) { Guid v; var r = Guid.TryParse(s, out v); p = v; return r; }; } else if (t == typeof(Byte[])) { // Assume hex representation return delegate(string s, out object p) { int start; s = s.Trim(); if (s.StartsWith("0x")) { if (s.Length < 4 || s.Length % 2 != 0) { p = null; return false; } start = 2; } else { if (s.Length < 2 || s.Length % 2 != 0) { p = null; return false; } start = 0; } var count = (s.Length - start) / 2; var buffer = new Byte[count]; // TODO: This could be further optimized by parsing ulong values instead of bytes... for (int i = 0; i < buffer.Length; i++) { // TODO: This one here can also be optimized, for example, not to call substring buffer[i] = byte.Parse(s.Substring(i * 2, 2), NumberStyles.HexNumber); } p = buffer; return true; }; } throw new NotImplementedException(); }
/// <summary> /// Generates the SQL script to create the table /// </summary> /// <param name="schemaTable"></param> /// <returns></returns> public string GenerateCreateDestinationTableQuery(DataTable schemaTable, Table destinationTable) { var sql = "CREATE TABLE [{0}].[{1}] ({2})"; var columnlist = String.Empty; var keylist = String.Empty; var nokey = false; int cidx = 0; int kidx = 0; for (int i = 0; i < schemaTable.Rows.Count; i++) { var column = new Column(); TypeUtil.CopyColumnFromSchemaTableRow(column, schemaTable.Rows[i]); if (!column.IsHidden) { if (cidx != 0) { columnlist += ",\r\n"; } columnlist += String.Format( "{0} {1} {2} NULL", column.Name, column.DataType.NameWithLength, column.IsNullable ? "" : "NOT"); cidx++; } /* if (column.IsKey) { if (column.IsHidden) { // The key is not returned by the query, so no key can be specified on // the final table nokey = true; } if (kidx != 0) { keylist += ",\r\n"; } keylist += String.Format("[{0}] ASC", column.Name); kidx++; } * */ } // Key generation code removed, key cannot be figured out automatically for // join queries /* if (!String.IsNullOrEmpty(keylist) && !nokey) { columnlist += String.Format( @", CONSTRAINT [{0}] PRIMARY KEY CLUSTERED ({1})", String.Format("PK_{0}", destinationTable.TableName), keylist); } * */ sql = String.Format(sql, destinationTable.SchemaName, destinationTable.TableName, columnlist); return sql; }
protected virtual FormatterDelegate GetFormatterDelegate(Column column) { var t = column.DataType.Type; if (t == typeof(SByte)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (SByte)o); }; } else if (t == typeof(Int16)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (Int16)o); }; } else if (t == typeof(Int32)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (Int32)o); }; } else if (t == typeof(Int64)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (Int64)o); }; } else if (t == typeof(Byte)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (Byte)o); }; } else if (t == typeof(UInt16)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (UInt16)o); }; } else if (t == typeof(UInt32)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (UInt32)o); }; } else if (t == typeof(UInt64)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (UInt64)o); }; } else if (t == typeof(Boolean)) { // TODO: use numbers? return delegate(object o, string f) { return String.Format(File.Culture, f, (bool)o); }; } else if (t == typeof(Single)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (float)o); }; } else if (t == typeof(Double)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (double)o); }; } else if (t == typeof(Decimal)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (decimal)o); }; } else if (t == typeof(Char)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (string)o); }; } else if (t == typeof(String)) { return delegate(object o, string f) { return (string)o; }; } else if (t == typeof(DateTime)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (DateTime)o); }; } else if (t == typeof(DateTimeOffset)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (DateTimeOffset)o); }; } else if (t == typeof(TimeSpan)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (TimeSpan)o); }; } else if (t == typeof(Guid)) { return delegate(object o, string f) { return String.Format(File.Culture, f, (Guid)o); }; } else if (t == typeof(byte[])) { return delegate(object o, string f) { var buffer = (byte[])o; if (buffer.Length == 0) { return null; // *** TODO: test if returning null's OK, otherwise return "" } else { var sb = new StringBuilder(); sb.Append("0x"); for (int i = 0; i < buffer.Length; i++) { sb.AppendFormat("{0:X}", buffer[i]); } return sb.ToString(); } }; } throw new NotImplementedException(); }
/// <summary> /// Detect column types from a set of values /// </summary> /// <param name="parts"></param> /// <param name="cols"></param> /// <param name="colranks"></param> protected void DetectColumnTypes(string[] parts, Column[] cols, int[] colranks) { for (int i = 0; i < cols.Length; i++) { Type type; int size, rank; if (!GetBestColumnTypeEstimate(parts[i], out type, out size, out rank)) { cols[i].DataType.IsNullable = true; } if (cols[i].DataType == null || colranks[i] < rank) { cols[i].DataType = DataType.Create(type, (short)size); } // Make column longer if necessary if (cols[i].DataType.HasLength && cols[i].DataType.Length < size) { cols[i].DataType.Length = (short)size; } } }
/// <summary> /// Generates a column list from a data reader. /// </summary> /// <param name="dr"></param> internal void DetectColumns(IDataReader dr) { var dt = dr.GetSchemaTable(); Column[] cols; if (this.Columns.Count == dt.Rows.Count) { cols = Columns.ToArray(); // *** TODO verify type mismatch, or update types // keep column name and format } else { cols = new Column[dt.Rows.Count]; for (int i = 0; i < dt.Rows.Count; i++) { cols[i] = Column.Create(dt.Rows[i]); } } CreateColumns(cols); }
/// <summary> /// Call this function to set column list from derived classes /// </summary> /// <param name="columns"></param> protected void CreateColumns(Column[] columns) { this.columns.Clear(); if (file.FileMode == DataFileMode.Read && file.GenerateIdentityColumn) { var col = new Column("__ID", DataType.SqlBigInt); // *** TODO col.IsIdentity = true; this.columns.Add(col); } this.columns.AddRange(columns); OnColumnsCreated(); }
/// <summary> /// Detects columns from a set of values. /// </summary> /// <param name="parts"></param> /// <param name="useNames"></param> /// <param name="cols"></param> /// <param name="colRanks"></param> /// <remarks> /// If it is the first line and useName is true, it will use them as column names, /// otherwise parts are only counted, columns are created for each and automatically generated /// names are used. /// </remarks> protected void DetectColumnsFromParts(string[] parts, bool useNames, out Column[] cols, out int[] colRanks) { cols = new Column[parts.Length]; colRanks = new int[parts.Length]; for (int i = 0; i < cols.Length; i++) { cols[i] = new Column(); if (useNames) { cols[i].Name = parts[i].Trim(); } else { cols[i].Name = String.Format("Col{0}", i); // *** TODO: use constants } } }