示例#1
0
        public ColumnReference(TableReference tableReference, Column columnDescription)
        {
            InitializeMembers();

            this.tableReference = tableReference;
            this.columnName = columnDescription.Name;
            this.dataType = columnDescription.DataType;
        }
示例#2
0
 /// <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;
 }
示例#3
0
 /// <summary>
 /// Copy constructor
 /// </summary>
 /// <param name="old"></param>
 public Column(Column old)
 {
     CopyMembers(old);
 }
示例#4
0
        public static Column Create(DataRow dr)
        {
            var column = new Column();
            column.CopyFromSchemaTableRow(dr);

            return column;
        }
示例#5
0
        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;
        }
示例#6
0
        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);
        }
示例#7
0
        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;
                }
            }
        }
示例#12
0
        /// <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);
        }
示例#13
0
        /// <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();
        }
示例#14
0
        /// <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
                }
            }
        }