Ejemplo n.º 1
0
        /// <summary>
        /// Specifies the foreign key that is to be used in relation.
        /// The foreign key should be explicitly given when there is more than one relation between two tables.
        /// </summary>
        /// <typeparam name="T">The type of the node.</typeparam>
        /// <param name="node">The node to which belongs the foreign key.</param>
        /// <param name="column">The column that is part of the foreign key.</param>
        public static DbTable <T> By <T>(this DbTable <T> node, string column)
            where T : DbRow
        {
            // null check
            if (node == null)
            {
                throw new QueryTalkException(".By", QueryTalkExceptionType.ArgumentNull, "node", Text.Method.By);
            }
            if (column == null)
            {
                throw new QueryTalkException(".By", QueryTalkExceptionType.ArgumentNull, "column", Text.Method.By);
            }

            var       nodeMap   = DbMapping.GetNodeMap(node.NodeID);
            ColumnMap columnMap = null;

            foreach (var col in nodeMap.Columns)
            {
                if (Api.IsEqual(col.Name.Part1, column))
                {
                    columnMap = col;
                    break;
                }
            }

            if (columnMap == null)
            {
                throw new QueryTalkException(".By", QueryTalkExceptionType.ColumnNotFound,
                                             String.Format("node = {0}{1}   column = {2}", node.Name, Environment.NewLine, column), Text.Method.By)
                      .SetObjectName(node.Name);
            }

            ((IRelation)node).FK = columnMap.ID;

            return(node);
        }
Ejemplo n.º 2
0
        internal static DataTable ToDataTable <U>(IEnumerable <U> collection)
        {
            string collectionTypeName;
            Type   tableType = typeof(U);

            if (collection == null)
            {
                throw new QueryTalkException("ToDataTable<T>", QueryTalkExceptionType.CollectionNullOrEmpty,
                                             String.Format("data class = {0}", tableType), Text.Method.ToDataTable);
            }

            collectionTypeName = collection.GetType().Name;
            if (collection is Wall.IResult)
            {
                collectionTypeName = Text.Class.ResultSet;
            }

            if (collectionTypeName == Text.Class.ResultSet)
            {
                var resultSet = (ResultSet <U>)collection;

                if (resultSet.DataTable != null)
                {
                    return(resultSet.DataTable);
                }

                // check dynamic - not convertable
                if (tableType == typeof(System.Object))
                {
                    if (collection.Count() == 0)
                    {
                        throw new QueryTalkException("ResultSet.getTableType", QueryTalkExceptionType.EmptyResultset,
                                                     "table type = dynamic", Text.Method.ToDataTable);
                    }

                    // infer type from the item
                    using (var enumerator = collection.GetEnumerator())
                    {
                        enumerator.MoveNext();
                        tableType = enumerator.Current.GetType();
                    }
                }
            }

            DataTable dataTable = new DataTable();

            dataTable.Locale = System.Globalization.CultureInfo.InvariantCulture;

            // always build new getters (not using cache)
            var getters = new List <IPropertyAccessor>();

            var props = tableType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
                        .Where(prop => prop.GetGetMethod() != null)
                        .ToArray();

            PropertyInfo[] properties;

            if (tableType.IsDbRow())
            {
                var node = DbMapping.GetNodeMap(tableType);
                var propsByDatabaseOrder = new List <PropertyInfo>();
                foreach (var column in node.SortedColumnsByDatabaseOrder)
                {
                    var prop = props.Where(a => a.Name.EqualsCS(column.ClrName)).Select(a => a).FirstOrDefault();
                    if (prop != null)
                    {
                        propsByDatabaseOrder.Add(prop);
                    }
                }

                properties = propsByDatabaseOrder.ToArray();
            }
            else
            {
                properties = props;
            }

            if (properties.Length == 0)
            {
                throw new QueryTalkException("ResultSet.ToDataTable", QueryTalkExceptionType.InvalidDataClass,
                                             String.Format("data class = {0}", tableType), Text.Method.ToDataTable);
            }

            int numberOfPropertiesUsed = 0;

            foreach (PropertyInfo property in properties)
            {
                Type clrType;
                QueryTalkException exception;

                var clrTypeMatch = Mapping.CheckClrCompliance(property.PropertyType, out clrType, out exception);
                if (clrTypeMatch == Mapping.ClrTypeMatch.NodeMatch)
                {
                    continue;
                }

                if (clrTypeMatch != Mapping.ClrTypeMatch.ClrMatch)
                {
                    ThrowNotClrCompliantException(exception, property.PropertyType);
                }

                dataTable.Columns.Add(property.Name, clrType);

                getters.Add(PropertyAccessor.Create(tableType, property));

                ++numberOfPropertiesUsed;
            }

            foreach (U item in collection)
            {
                DataRow row = dataTable.NewRow();
                for (int i = 0; i < numberOfPropertiesUsed; i++)
                {
                    row[i] = getters[i].GetValue(item) ?? DBNull.Value;
                }

                dataTable.Rows.Add(row);
            }

            return(dataTable);
        }