/// <summary>Read in static rating data from a file</summary>
        /// <param name="filename">the name of the file to read from</param>
        /// <param name="user_mapping">mapping object for user IDs</param>
        /// <param name="item_mapping">mapping object for item IDs</param>
        /// <param name="rating_type">the data type to be used for storing the ratings</param>
        /// <param name="ignore_first_line">if true, ignore the first line</param>
        /// <returns>the rating data</returns>
        public static IRatings Read(
            string filename,
			IEntityMapping user_mapping = null, IEntityMapping item_mapping = null,
			RatingType rating_type = RatingType.FLOAT,
			bool ignore_first_line = false)
        {
            string binary_filename = filename + ".bin.StaticRatings";
            if (FileSerializer.Should(user_mapping, item_mapping) && File.Exists(binary_filename))
                return (IRatings) FileSerializer.Deserialize(binary_filename);

            int size = 0;
            using ( var reader = new StreamReader(filename) )
                while (reader.ReadLine() != null)
                    size++;
            if (ignore_first_line)
                size--;

            return Wrap.FormatException<IRatings>(filename, delegate() {
                using ( var reader = new StreamReader(filename) )
                {
                    var ratings = (StaticRatings) Read(reader, size, user_mapping, item_mapping, rating_type);
                    if (FileSerializer.Should(user_mapping, item_mapping) && FileSerializer.CanWrite(binary_filename))
                        ratings.Serialize(binary_filename);
                    return ratings;
                }
            });
        }

        /// <summary>Read in rating data from a TextReader</summary>
        /// <param name="reader">the <see cref="TextReader"/> to read from</param>
        /// <param name="user_mapping">mapping object for user IDs</param>
        /// <param name="item_mapping">mapping object for item IDs</param>
        /// <returns>the rating data</returns>
        public static ITimedRatings Read(TextReader reader, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null)
        {
            if (user_mapping == null)
                user_mapping = new IdentityMapping();
            if (item_mapping == null)
                item_mapping = new IdentityMapping();

            var ratings = new TimedRatings();

            string[] separators = { "::" };
            string line;

            while ((line = reader.ReadLine()) != null)
            {
                string[] tokens = line.Split(separators, StringSplitOptions.None);

                if (tokens.Length < 4)
                    throw new FormatException(string.Format("Expected at least 4 columns: {0}", line));

                int user_id = user_mapping.ToInternalID(tokens[0]);
                int item_id = item_mapping.ToInternalID(tokens[1]);
                float rating = float.Parse(tokens[2], CultureInfo.InvariantCulture);
                long seconds = uint.Parse(tokens[3]);

                var time = new DateTime(seconds * 10000000L).AddYears(1969);
                var offset = TimeZone.CurrentTimeZone.GetUtcOffset(time);
                time -= offset;

                ratings.Add(user_id, item_id, rating, time);
            }
            return ratings;
        }

        /// <summary>Read binary relation data from file</summary>
        /// <remarks>
        /// The expected (sparse) line format is:
        /// ENTITY_ID whitespace ENTITY_ID
        /// for the relations that hold.
        /// </remarks>
        /// <param name="reader">a StreamReader to be read from</param>
        /// <param name="mapping">the mapping object for the given entity type</param>
        /// <returns>the relation data</returns>
        public static SparseBooleanMatrix Read(StreamReader reader, IEntityMapping mapping)
        {
            var matrix = new SparseBooleanMatrix();

            char[] split_chars = new char[]{ '\t', ' ' };
            string line;

            while (!reader.EndOfStream)
            {
               	line = reader.ReadLine();

                // ignore empty lines
                if (line.Length == 0)
                    continue;

                string[] tokens = line.Split(split_chars);

                if (tokens.Length != 2)
                    throw new IOException("Expected exactly two columns: " + line);

                int entity1_id = mapping.ToInternalID(int.Parse(tokens[0]));
                int entity2_id = mapping.ToInternalID(int.Parse(tokens[1]));

               	matrix[entity1_id, entity2_id] = true;
            }

            return matrix;
        }

 /// <summary>Read binary attribute data from a file</summary>
 /// <remarks>
 /// The expected (sparse) line format is:
 /// ENTITY_ID tab/space/comma ATTRIBUTE_ID
 /// for the relations that hold.
 /// </remarks>
 /// <param name="filename">the name of the file to be read from</param>
 /// <param name="mapping">the mapping object for the given entity type</param>
 /// <returns>the attribute data</returns>
 public static SparseBooleanMatrix Read(string filename, IEntityMapping mapping)
 {
     return Wrap.FormatException<SparseBooleanMatrix>(filename, delegate() {
         using ( var reader = new StreamReader(filename) )
             return Read(reader, mapping);
     });
 }

        /// <summary>Read in implicit feedback data from a TextReader</summary>
        /// <param name="reader">the TextReader to be read from</param>
        /// <param name="user_mapping">user <see cref="IEntityMapping"/> object</param>
        /// <param name="item_mapping">item <see cref="IEntityMapping"/> object</param>
        /// <returns>a <see cref="IPosOnlyFeedback"/> object with the user-wise collaborative data</returns>
        public static IPosOnlyFeedback Read(TextReader reader, IEntityMapping user_mapping, IEntityMapping item_mapping)
        {
            var feedback = new PosOnlyFeedback<SparseBooleanMatrix>();

            var split_chars = new char[]{ '\t', ' ', ',' };
            string line;

            while ( (line = reader.ReadLine()) != null )
            {
                if (line.Trim().Length == 0)
                    continue;

                string[] tokens = line.Split(split_chars);

                if (tokens.Length < 2)
                    throw new IOException("Expected at least two columns: " + line);

                int user_id = user_mapping.ToInternalID(int.Parse(tokens[0]));
                int item_id = item_mapping.ToInternalID(int.Parse(tokens[1]));

               	feedback.Add(user_id, item_id);
            }

            return feedback;
        }

        /// <summary>Read in rating data which will be interpreted as implicit feedback data from a TextReader</summary>
        /// <param name="reader">the TextReader to be read from</param>
        /// <param name="rating_threshold">the minimum rating value needed to be accepted as positive feedback</param>
        /// <param name="user_mapping">user <see cref="IEntityMapping"/> object</param>
        /// <param name="item_mapping">item <see cref="IEntityMapping"/> object</param>
        /// <param name="ignore_first_line">if true, ignore the first line</param>
        /// <returns>a <see cref="IPosOnlyFeedback"/> object with the user-wise collaborative data</returns>
        public static IPosOnlyFeedback Read(TextReader reader, float rating_threshold, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null, bool ignore_first_line = false)
        {
            if (user_mapping == null)
                user_mapping = new IdentityMapping();
            if (item_mapping == null)
                item_mapping = new IdentityMapping();
            if (ignore_first_line)
                reader.ReadLine();

            var feedback = new PosOnlyFeedback<SparseBooleanMatrix>();

            string line;
            while ((line = reader.ReadLine()) != null)
            {
                if (line.Trim().Length == 0)
                    continue;

                string[] tokens = line.Split(Constants.SPLIT_CHARS);

                if (tokens.Length < 3)
                    throw new FormatException("Expected at least 3 columns: " + line);

                int user_id   = user_mapping.ToInternalID(tokens[0]);
                int item_id   = item_mapping.ToInternalID(tokens[1]);
                float rating  = float.Parse(tokens[2], CultureInfo.InvariantCulture);

                if (rating >= rating_threshold)
                    feedback.Add(user_id, item_id);
            }

            return feedback;
        }

        /// <summary>Read in static rating data from a TextReader</summary>
        /// <param name="reader">the <see cref="TextReader"/> to read from</param>
        /// <param name="size">the number of ratings in the file</param>
        /// <param name="user_mapping">mapping object for user IDs</param>
        /// <param name="item_mapping">mapping object for item IDs</param>
        /// <param name="rating_type">the data type to be used for storing the ratings</param>
        /// <returns>the rating data</returns>
        public static IRatings Read(TextReader reader, int size,
            IEntityMapping user_mapping, IEntityMapping item_mapping,
            RatingType rating_type)
        {
            IRatings ratings;
            if (rating_type == RatingType.BYTE)
                ratings = new StaticByteRatings(size);
            else if (rating_type == RatingType.FLOAT)
                ratings = new StaticFloatRatings(size);
            else
                ratings = new StaticRatings(size);

            var split_chars = new char[]{ '\t', ' ', ',' };
            string line;

            while ( (line = reader.ReadLine()) != null )
            {
                if (line.Length == 0)
                    continue;

                string[] tokens = line.Split(split_chars);

                if (tokens.Length < 3)
                    throw new IOException("Expected at least three columns: " + line);

                int user_id = user_mapping.ToInternalID(int.Parse(tokens[0]));
                int item_id = item_mapping.ToInternalID(int.Parse(tokens[1]));
                double rating = double.Parse(tokens[2], CultureInfo.InvariantCulture);

                ratings.Add(user_id, item_id, rating);
            }
            return ratings;
        }

        /// <summary>Read in rating data from a TextReader</summary>
        /// <param name="reader">the <see cref="TextReader"/> to read from</param>
        /// <param name="user_mapping">mapping object for user IDs</param>
        /// <param name="item_mapping">mapping object for item IDs</param>
        /// <param name="ignore_first_line">if true, ignore the first line</param>
        /// <returns>the rating data</returns>
        public static IRatings Read(TextReader reader, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null, bool ignore_first_line = false)
        {
            if (user_mapping == null)
                user_mapping = new IdentityMapping();
            if (item_mapping == null)
                item_mapping = new IdentityMapping();
            if (ignore_first_line)
                reader.ReadLine();

            var ratings = new Ratings();

            string line;
            while ( (line = reader.ReadLine()) != null )
            {
                if (line.Length == 0)
                    continue;

                string[] tokens = line.Split(Constants.SPLIT_CHARS);

                if (tokens.Length < 3)
                    throw new FormatException("Expected at least 3 columns: " + line);

                int user_id = user_mapping.ToInternalID(tokens[0]);
                int item_id = item_mapping.ToInternalID(tokens[1]);
                float rating = float.Parse(tokens[2], CultureInfo.InvariantCulture);

                ratings.Add(user_id, item_id, rating);
            }
            return ratings;
        }

        public MemberMapping(MemberInfo memberInfo,  MemberAttribute memberAttribute, IEntityMapping entityMapping)
        {
            this.entity = entityMapping;

            this.memberInfo = memberInfo;

            this.memberAttribute = memberAttribute;

            this.memberType = memberInfo.GetMemberType();

            if (memberAttribute is ColumnAttribute)
            {
                this.InitializeColumnAttributeMapping((ColumnAttribute)memberAttribute);
            }
            else if (memberAttribute is AssociationAttribute)
            {
                var isEnumerableType = memberType != typeof(string) &&
                                       memberType != typeof(byte[]) &&
                                       typeof(IEnumerable).IsAssignableFrom(memberType);

                this.isRelationship = true;

                this.InitializeAssociationAttributeMapping((AssociationAttribute)memberAttribute, isEnumerableType);
            }
        }

        public virtual Expression BuildEntityExpression(IEntityMapping mapping, IList<EntityAssignment> assignments)
        {
            NewExpression newExpression;

            // handle cases where members are not directly assignable
            EntityAssignment[] readonlyMembers = assignments.Where(b => b.MemberMapping != null)
                .Where(b => (b.MemberMapping as MemberMapping).setter == null)
                .ToArray();
            ConstructorInfo[] cons = mapping.EntityType.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
            bool hasNoArgConstructor = cons.Any(c => c.GetParameters().Length == 0);

            if (readonlyMembers.Length > 0 || !hasNoArgConstructor)
            {
                var consThatApply = cons
                                        .Select(c => this.BindConstructor(c, readonlyMembers))
                                        .Where(cbr => cbr != null && cbr.Remaining.Length == 0)
                                        .ToList();
                if (consThatApply.Count == 0)
                    throw new InvalidOperationException(string.Format(Res.ConstructTypeInvalid, mapping.EntityType));

                // just use the first one... (Note: need better algorithm. :-)
                if (readonlyMembers.Length == assignments.Count)
                    return consThatApply[0].Expression;
                var r = this.BindConstructor(consThatApply[0].Expression.Constructor, assignments);

                newExpression = r.Expression;
                assignments = r.Remaining;
            }
            else
                newExpression = Expression.New(mapping.EntityType);

            Expression result;
            if (assignments.Count > 0)
            {
                if (mapping.EntityType.IsInterface)
                    assignments = this.MapAssignments(assignments, mapping.EntityType).ToList();
                var memberBindings = new List<MemberBinding>();
                foreach (var a in assignments)
                {
                    try
                    {
                        memberBindings.Add(Expression.Bind(a.Member, a.Expression));
                    }
                    catch
                    {
                        throw;
                    }
                }
                result = Expression.MemberInit(newExpression, memberBindings.ToArray());
            }
            else
                result = newExpression;

            if (mapping.EntityType != mapping.EntityType)
                result = Expression.Convert(result, mapping.EntityType);
            return result;
        }

        public Uri SelectGraph(EntityId entityId, IEntityMapping entityMapping, IPropertyMapping predicate)
        {
            EntityId nonBlankId = entityId;
            if (nonBlankId is BlankId)
            {
                nonBlankId = ((BlankId)nonBlankId).RootEntityId;
            }

            return new Uri(System.Text.RegularExpressions.Regex.Replace((nonBlankId != null ? nonBlankId.Uri.AbsoluteUri : ((BlankId)entityId).Graph.AbsoluteUri), "((?<!data.)magi)", "data.magi"));
        }

        /// <summary>
        /// Sets the currently processed enitty type
        /// and updates inheritance cache
        /// </summary>
        public void Visit(IEntityMapping entityMapping)
        {
            if (!_classMappings.ContainsKey(entityMapping.EntityType))
            {
                _classMappings.Add(entityMapping.EntityType, new List<IClassMapping>());
            }

            AddAsChildOfParentTypes(entityMapping.EntityType);

            _currentClasses = _classMappings[entityMapping.EntityType];
        }

        /// <summary>Write item predictions (scores) to a file</summary>
        /// <param name="recommender">the <see cref="IRecommender"/> to use for making the predictions</param>
        /// <param name="train">a user-wise <see cref="IPosOnlyFeedback"/> containing the items already observed</param>
        /// <param name="candidate_items">list of candidate items</param>
        /// <param name="num_predictions">number of items to return per user, -1 if there should be no limit</param>
        /// <param name="filename">the name of the file to write to</param>
        /// <param name="users">a list of users to make recommendations for</param>
        /// <param name="user_mapping">an <see cref="IEntityMapping"/> object for the user IDs</param>
        /// <param name="item_mapping">an <see cref="IEntityMapping"/> object for the item IDs</param>
        public static void WritePredictions(
			this IRecommender recommender,
			IPosOnlyFeedback train,
			System.Collections.Generic.IList<int> candidate_items,
			int num_predictions,
			string filename,
			System.Collections.Generic.IList<int> users = null,
			IEntityMapping user_mapping = null, IEntityMapping item_mapping = null)
        {
            using (var writer = new StreamWriter(filename))
                WritePredictions(recommender, train, candidate_items, num_predictions, writer, users, user_mapping, item_mapping);
        }

 protected override string[] BuildSchemaScript(IEntityMapping[] mappings)
 {
     return new string[]{
         mappings
              .Where(p => p.Schema.HasValue()
                  && p.Schema.Trim().ToUpper() != "DBO"
                  && p.Schema.Trim().ToUpper() != "[DBO]")
              .Select(p => p.Schema.Trim().ToLower())
              .Distinct()
              .Select(p => string.Format("{0} CREATE SCHEMA {1}{0} ", Environment.NewLine, p))
              .ToCSV(";")
     };
 }

        /// <summary>Rate a given set of instances and write it to a file</summary>
        /// <param name="recommender">rating predictor</param>
        /// <param name="ratings">test cases</param>
        /// <param name="user_mapping">an <see cref="EntityMapping"/> object for the user IDs</param>
        /// <param name="item_mapping">an <see cref="EntityMapping"/> object for the item IDs</param>
        /// <param name="line_format">a format string specifying the line format; {0} is the user ID, {1} the item ID, {2} the rating</param>
        /// <param name="filename">the name of the file to write the predictions to</param>
        public static void WritePredictions(
			IRatingPredictor recommender,
			IRatings ratings,
			IEntityMapping user_mapping, IEntityMapping item_mapping,
		    string line_format,
			string filename)
        {
            if (filename.Equals("-"))
                WritePredictions(recommender, ratings, user_mapping, item_mapping, line_format, Console.Out);
            else
                using ( var writer = new StreamWriter(filename) )
                    WritePredictions(recommender, ratings, user_mapping, item_mapping, line_format, writer);
        }

        public Uri SelectGraph(EntityId entityId, IEntityMapping entityMapping, IPropertyMapping predicate)
        {
            if (entityId is BlankId)
            {
                EntityId nonBlankId = ((BlankId)entityId).RootEntityId;
                if (nonBlankId != null)
                {
                    entityId = nonBlankId;
                }
            }

            return entityId.Uri;
        }

		private void BindPersistentClassCommonValues(IEntityMapping classMapping, PersistentClass model, IDictionary<string, MetaAttribute> inheritedMetas)
		{
			// DISCRIMINATOR
			var discriminable = classMapping as IEntityDiscriminableMapping;
			model.DiscriminatorValue = (discriminable == null || string.IsNullOrEmpty(discriminable.DiscriminatorValue)) ? model.EntityName : discriminable.DiscriminatorValue;

			// DYNAMIC UPDATE
			model.DynamicUpdate = classMapping.DynamicUpdate;

			// DYNAMIC INSERT
			model.DynamicInsert = classMapping.DynamicInsert;

			// IMPORT
			// For entities, the EntityName is the key to find a persister
			// NH Different behavior: we are using the association between EntityName and its more certain implementation (AssemblyQualifiedName)
			// Dynamic entities have no class, reverts to EntityName. -AK
			string qualifiedName = model.MappedClass == null ? model.EntityName : model.MappedClass.AssemblyQualifiedName;
			mappings.AddImport(qualifiedName, model.EntityName);
			if (mappings.IsAutoImport && model.EntityName.IndexOf('.') > 0)
				mappings.AddImport(qualifiedName, StringHelper.Unqualify(model.EntityName));

			// BATCH SIZE
			if (classMapping.BatchSize.HasValue)
				model.BatchSize = classMapping.BatchSize.Value;

			// SELECT BEFORE UPDATE
			model.SelectBeforeUpdate = classMapping.SelectBeforeUpdate;

			// META ATTRIBUTES
			model.MetaAttributes = GetMetas(classMapping, inheritedMetas);

			// PERSISTER
			if(!string.IsNullOrEmpty(classMapping.Persister))
				model.EntityPersisterClass = ClassForNameChecked(classMapping.Persister, mappings,
				                                                 "could not instantiate persister class: {0}");

			// CUSTOM SQL
			HandleCustomSQL(classMapping, model);
			if (classMapping.SqlLoader != null)
				model.LoaderName = classMapping.SqlLoader.queryref;

			foreach (var synchronize in classMapping.Synchronize)
			{
				model.AddSynchronizedTable(synchronize.table);
			}

			model.IsAbstract = classMapping.IsAbstract;
		}

        /// <summary>Read in implicit feedback data from a file</summary>
        /// <param name="filename">name of the file to be read from</param>
        /// <param name="user_mapping">user <see cref="IEntityMapping"/> object</param>
        /// <param name="item_mapping">item <see cref="IEntityMapping"/> object</param>
        /// <param name="ignore_first_line">if true, ignore the first line</param>
        /// <returns>a <see cref="IPosOnlyFeedback"/> object with the user-wise collaborative data</returns>
        public static IPosOnlyFeedback Read(string filename, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null, bool ignore_first_line = false)
        {
            string binary_filename = filename + ".bin.PosOnlyFeedback";
            if (FileSerializer.Should(user_mapping, item_mapping) && File.Exists(binary_filename))
                return (IPosOnlyFeedback) FileSerializer.Deserialize(binary_filename);

            return Wrap.FormatException<IPosOnlyFeedback>(filename, delegate() {
                using ( var reader = new StreamReader(filename) )
                {
                    var feedback_data = (ISerializable) Read(reader, user_mapping, item_mapping);
                    if (FileSerializer.Should(user_mapping, item_mapping) && FileSerializer.CanWrite(binary_filename))
                        feedback_data.Serialize(binary_filename);
                    return (IPosOnlyFeedback) feedback_data;
                }
            });
        }

        protected override List<ColumnAssignment> GetInsertColumnAssignments(Expression table, Expression instance, IEntityMapping entity, Func<IMemberMapping, bool> fnIncludeColumn)
        {
            var items = base.GetInsertColumnAssignments(table, instance, entity, fnIncludeColumn);
            var pk = entity.PrimaryKeys.FirstOrDefault(p => p.IsGenerated);
            if (pk != null)
            {
                var sequenceName = string.IsNullOrEmpty(pk.SequenceName) ? "NEXTID" : pk.SequenceName;

                var ca = new ColumnAssignment(
                                (ColumnExpression)this.GetMemberExpression(table, entity, pk.Member),
                                 new FunctionExpression(pk.MemberType, sequenceName + ".NEXTVAL", null)
                                );
                items.Add(ca);
            }
            return items;
        }

		protected void BindClass(IEntityMapping classMapping, PersistentClass model, IDictionary<string, MetaAttribute> inheritedMetas)
		{
			// handle the lazy attribute
			// go ahead and set the lazy here, since pojo.proxy can override it.
			model.IsLazy = classMapping.UseLazy.HasValue ? classMapping.UseLazy.Value : mappings.DefaultLazy;

			// transfer an explicitly defined entity name
			string entityName = classMapping.EntityName ??
								ClassForNameChecked(classMapping.Name, mappings, "persistent class {0} not found").FullName;
			if (entityName == null)
				throw new MappingException("Unable to determine entity name");
			model.EntityName = entityName;

			BindPocoRepresentation(classMapping, model);
			BindXmlRepresentation(classMapping, model);
			BindMapRepresentation(classMapping, model);

			BindPersistentClassCommonValues(classMapping, model, inheritedMetas);
		}