public static Statement CreateStatement(Insert insert, IEntityMapping mapping) { var writer = new SqlWriter(); IDictionary <string, object> parameters = null; writer.InsertInto.QuotedName(insert.Into.Name); var resultType = Statement.ResultType.None; switch (insert.Type) { case Insert.SetType.Values: writer.OpenBlock.Trim().FieldList(x => x.Comma.Flush(), insert.Values.Keys).Trim().CloseBlock.Flush(); parameters = new Dictionary <string, object>(); writer.Values.OpenBlock.Trim().ParameterList(x => x.Comma.Flush(), insert.Values.Values.Select(x => parameters.AddWithUniquelyNamedKey(x))). Trim().CloseBlock.Flush(); if (insert.HasIdentityKey) { writer.Trim().QuerySeperator.Select.ScopeIdentity(typeof(int)); resultType = Statement.ResultType.Scalar; } break; case Insert.SetType.Query: var select = SelectWriter <TEntity> .CreateStatement(insert.Query, mapping); parameters = select.Parameters; writer.OpenBlock.Trim().FieldList(x => x.Comma.Flush(), SelectWriter <TEntity> .BuildProjection(insert.Query, mapping, parameters)).Trim().CloseBlock.Flush(); writer.Write(select.Text); break; } return(new Statement(writer.ToString(), Statement.StatementType.Text, resultType, parameters)); }
/// <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; }
public IHttpActionResult Put(int id, int mappingid, [IfMatch] ETag etag, [FromBody] Mapping mapping) { return(WebHandler(() => { IEntityMapping returnedMapping = null; var request = new AmendMappingRequest { EntityId = id, MappingId = mappingid, Mapping = mapping, Version = etag.ToVersion() }; using (var scope = new TransactionScope(TransactionScopeOption.Required, WriteOptions())) { returnedMapping = this.service.UpdateMapping(request); scope.Complete(); } if (returnedMapping != null) { notificationService.Notify(() => GetContract(id, etag.ToVersion()).Contract, service.ContractVersion, Operation.Modified); return new StatusCodeResultWithLocation(this.Request, HttpStatusCode.NoContent, this.Request.RequestUri.AbsolutePath.Substring(1)); } return NotFound(); })); }
Read(TextReader reader, IEntityMapping user_mapping, IEntityMapping item_mapping) { var ratings = new Ratings(); 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); }
IDbSet GetDbSet(IEntityMapping entity) { IDbSet table; table = this.CreateDbSet(entity); return(table); }
/// <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> static public 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); }
/// <inheritdoc /> public override Uri SelectGraph(EntityId entityId, IEntityMapping entityMapping, IPropertyMapping predicate) { Uri result; var request = (CurrentRequest != null ? CurrentRequest() : null); if (request != null) { IDictionary <EntityId, Uri> requestMap; if ((_requestMappings.TryGetValue(request, out requestMap)) && (requestMap.TryGetValue(entityId, out result))) { return(result); } } if (Cache.TryGetValue(entityId, out result)) { return(result); } if (NamedGraph != null) { return(Cache[entityId] = NamedGraph); } return(base.SelectGraph(entityId, entityMapping, predicate)); }
private void BindPocoRepresentation(IEntityMapping classMapping, PersistentClass entity) { string className = classMapping.Name == null ? null : ClassForNameChecked(classMapping.Name, mappings, "persistent class {0} not found").AssemblyQualifiedName; entity.ClassName = className; if (!string.IsNullOrEmpty(classMapping.Proxy)) { entity.ProxyInterfaceName = ClassForNameChecked(classMapping.Proxy, mappings, "proxy class not found: {0}").AssemblyQualifiedName; entity.IsLazy = true; } else if (entity.IsLazy) { entity.ProxyInterfaceName = className; } HbmTuplizer tuplizer = classMapping.Tuplizers.FirstOrDefault(tp => tp.entitymode == HbmTuplizerEntitymode.Poco); if (tuplizer != null) { string tupClassName = FullQualifiedClassName(tuplizer.@class, mappings); entity.AddTuplizer(EntityMode.Poco, tupClassName); } }
/// <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; }
public static string GetInsertSql(this IEntityMapping mapping) { var properties = mapping.ValueProperties.Where(propertyMapping => !propertyMapping.IsDbGenerated).ToList(); return ($"{SqlTerm.Insert} {SqlTerm.Into} {mapping.TableName} ({string.Join(",", properties.GetColumnNames())}) {SqlTerm.Values} ({string.Join(",", properties.GetPropertyNames())}) "); }
internal Expression GetEntityExistsTest(IEntityMapping entity, Expression instance) { ProjectionExpression tq = this.GetQueryExpression(entity); Expression where = this.GetIdentityCheck(tq.Select, entity, instance); return(new ExistsExpression(new SelectExpression(new TableAlias(), null, tq.Select, where))); }
/// <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 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); }); }
public EntityContext( IEntityContextFactory factory, IMappingsRepository mappings, IEntityStore entityStore, IEntitySource entitySource, IBaseUriSelectionPolicy baseUriSelector, IRdfTypeCache typeCache, IBlankNodeIdGenerator blankIdGenerator, IResultTransformerCatalog transformerCatalog, IEntityCaster caster, IDatasetChangesTracker changeTracker, IResourceResolutionStrategy resourceResolutionStrategy, ILogger log) : this(changeTracker) { _factory = factory; _entityStore = entityStore; _entitySource = entitySource; _baseUriSelector = baseUriSelector; _mappings = mappings; _typeCache = typeCache; _blankIdGenerator = blankIdGenerator; _transformerCatalog = transformerCatalog; _caster = caster; _typedEntityMapping = _mappings.MappingFor <ITypedEntity>(); _typesPropertyMapping = _typedEntityMapping.PropertyFor("Types"); _resourceResolutionStrategy = resourceResolutionStrategy; _log = log; if (_baseUriSelector == null) { _log.Warning("No Base URI Selection Policy. It will not be possible to use relative URIs"); } }
public ColumnSetStatementCollectionBuilder(object entity, IEntityMapping entityMapping, SqlParameterCollection updateParameters) { _entity = entity; _entityMapping = entityMapping; Parameters = updateParameters; }
/// <inheritdoc /> public void Visit(IEntityMapping entityMapping) { if (!entityMapping.EntityType.GetTypeInfo().Assembly.IsDynamic) { _mappingAssemblies.Add(entityMapping.EntityType.GetTypeInfo().Assembly); } }
public static ISqlCommandMapping LinqToSqlWhere <T>(this IEntityMapping mapping, Expression <Func <T, bool> > expression) { return(mapping.LinqToSqlWhere(new List <Expression <Func <T, bool> > > { expression })); }
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 static ISqlCommandMapping LinqToSqlWhere <T>(this IEntityMapping mapping, IEnumerable <Expression <Func <T, bool> > > expressionList) { var sqlMapping = new SqlCommandMapping { CommandText = string.Empty, Parameters = new Dictionary <string, object>() }; foreach (var expression in expressionList) { var expressionMap = expression.GetWhereMapping(); var property = mapping.GetPropertyByName(expressionMap.PropertyName); sqlMapping.Parameters.Add($"@{expressionMap.PropertyName}", expressionMap.Value); if (sqlMapping.CommandText.Contains(SqlTerm.Where)) { sqlMapping.CommandText += $"{SqlTerm.And} {property.ColumnName} {expressionMap.Operator} :{expressionMap.PropertyName} "; } else { sqlMapping.CommandText += $"{SqlTerm.Where} {property.ColumnName} {expressionMap.Operator} :{expressionMap.PropertyName} "; } } return(sqlMapping); }
public static Statement CreateStatement(Delete delete, IEntityMapping mapping) { Statement statement = null; var writer = SqlWriter.CreateWriter().Delete; if (!delete.AllowMultiple) { writer.Top(1); } writer.From.QuotedName(delete.Table.Name); switch (delete.Filter) { case Delete.FilterType.Where: statement = WhereWriter <TEntity> .CreateStatement(delete.Where, mapping); writer.Where.Write(statement.Text); break; case Delete.FilterType.Select: var keyColumn = mapping.Key.GetColumnName(); statement = SelectWriter <TEntity> .CreateStatement(delete.Select, mapping); writer.Where.Exists.OpenBlock.Trim().Select.QuotedName(keyColumn).From.OpenBlock.Trim(). Write(statement.Text).Trim().CloseBlock.As.SubQueryAlias.Where.SubQueryColumn(keyColumn).Equal.QuotedName(delete.Table.Name, keyColumn).Trim().CloseBlock.Flush(); break; } return(new Statement(writer.ToString(), Statement.StatementType.Text, Statement.ResultType.None, statement.Parameters)); }
IDbSet CreateDbSet(IEntityMapping entity) { return(typeof(DbSet <>) .MakeGenericType(entity.EntityType) .GetConstructor(new Type[] { typeof(InternalDbContext), typeof(IEntityMapping) }) .FastInvoke(this, entity) as IDbSet); }
public UpdateStatementBuilder(object entity, IEntityMapping entityMapping) { _entity = entity; _entityMapping = entityMapping; _parameters = new SqlParameterCollection(); }
public Uri SelectGraph(EntityId id, IEntityMapping entityMapping, IPropertyMapping predicate) { string replacementProtocol = "http"; if (predicate != null && predicate.Uri != null) { switch (predicate.Uri.ToString()) { case "http://xmlns.com/foaf/0.1/familyName": case "http://xmlns.com/foaf/0.1/givenName": replacementProtocol = "personal"; break; case "http://xmlns.com/foaf/0.1/knows": replacementProtocol = "friendsOf"; break; case "http://xmlns.com/foaf/0.1/homePage": case "http://xmlns.com/foaf/0.1/interest": replacementProtocol = "interestsOf"; break; } } return(new Uri(id.ToString().Replace("http", replacementProtocol))); }
private static string BuildMergeInsertSet(this IEntityMapping mapping) { var command = new StringBuilder(); var columns = new List <string>(); var values = new List <string>(); var properties = mapping.Properties .Where(propertyMapping => !propertyMapping.IsDbGenerated) .ToList(); command.Append(" WHEN NOT MATCHED BY TARGET THEN INSERT "); if (properties.Any()) { foreach (var column in properties) { columns.Add($"[{column.ColumnName}]"); values.Add($"[{Source}].[{column.ColumnName}]"); } command.Append($"({string.Join(", ", columns)}) VALUES ({string.Join(", ", values)})"); } else { command.Append("DEFAULT VALUES"); } return(command.ToString()); }
/// <summary> /// </summary> /// <param name="mapping"></param> /// <param name="tableName"></param> /// <param name="operationType"></param> /// <param name="options"></param> /// <returns></returns> internal static string BuildStagingTableCommand(this IEntityMapping mapping, string tableName, Operation operationType, BulkOptions options) { var paramList = mapping .GetPropertiesByOperation(operationType) .ToList(); if (paramList.All(s => s.IsPk && s.IsDbGenerated) && operationType == Operation.Update) { return(null); } var paramColumns = paramList .Select(column => $"{Source}.[{column.ColumnName}]") .ToList(); if (mapping.WillOutputGeneratedValues(options)) { paramColumns.Add($"1 as [{Identity}]"); } var paramListConcatenated = string.Join(", ", paramColumns); return($"SELECT TOP 0 {paramListConcatenated} INTO {tableName} FROM {mapping.FullTableName} AS A " + $"LEFT JOIN {mapping.FullTableName} AS {Source} ON 1 = 2"); }
/// <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; }
/// <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; } }); }
public void ProcessFiles() { DirectoryInfo directoryInfo = new DirectoryInfo(ConfigurationManager.AppSettings[CSVConstants.FilePathLookup]); FileInfo[] files = directoryInfo.GetFiles(CSVConstants.FileExtension); foreach (var file in files) { if (this.fileTypeMapperDictionary.ContainsKey(Path.GetFileNameWithoutExtension(file.Name))) { string fileTypeClass = this.fileTypeMapperDictionary[Path.GetFileNameWithoutExtension(file.Name)]; ErrorInfo[] errorInfo = null; List <object> processedRecords = this.businessProcessor.ProcessCSVData(fileTypeClass, file.FullName, out errorInfo); //Creating Instance using Factory Pattern IEntityMapping entity = ObjectFactory.CreateFactoryInstance(fileTypeClass); //Processing records for DB insert. Only at run time, the corresponding class is known - Order or Customer entity.CreateEntityMapping(processedRecords); } else { throw new Exception("Invalid FileName. Not found in repository"); } } //Fetch Order and Customer mapping records from DB IEnumerable <CustomerOrder> dataset = edr.GetCustomerOrderData(); }
/// <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; }
private void InitializeAssociationAttributeMapping(AssociationAttribute association, bool isEnumerableType) { this.isForeignKey = association.IsForeignKey; if (this.isForeignKey || association is ManyToOneAttribute) { this.isManyToOne = true; } if (isEnumerableType) { this.relatedType = ReflectionHelper.GetElementType(this.MemberType); } else { this.relatedType = this.memberType; } var tableAttribute = this.relatedType.GetCustomAttributes <TableAttribute>().FirstOrDefault(); string thisKey = association.ThisKey; string otherKey = association.OtherKey; this.relatedEntity = new EntityMapping(tableAttribute.Name, this.relatedType, null); this.thisKeyMembers = thisKey.Split(separators).Select(m => GetMemberMapping(this.Entity.EntityType, m, this.entity)).ToArray(); this.otherKeyMembers = this.relatedEntity.PrimaryKeys; }
/// <summary>Read binary attribute data from a StreamReader</summary> /// <param name="reader">a StreamReader to be read from</param> /// <param name="mapping">the mapping object for the given entity type</param> /// <returns>the attribute data</returns> static public SparseBooleanMatrix Read(StreamReader reader, IEntityMapping mapping) { var matrix = new SparseBooleanMatrix(); var 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 entity_id = mapping.ToInternalID(int.Parse(tokens[0])); int attr_id = int.Parse(tokens[1]); matrix[entity_id, attr_id] = true; } return(matrix); }
private static string BuildWhereClause(Select select, IEntityMapping mapping, IDictionary <string, object> parameters) { if (!select.HasWhere && !select.HasSetOperations) { return(null); } var writer = new SqlWriter(); if (select.HasWhere) { writer.Write(BuildOperators(select.Where, mapping, parameters)); } if (select.HasSetOperations) { foreach (var setOperation in select.SetOperatons) { var statement = CreateStatement(setOperation.Select, mapping); parameters.AddRange(statement.Parameters); if (!writer.Empty) { writer.And.Flush(); } if (setOperation.Type == SetOperation.OperationType.Compliment) { writer.Not.Flush(); } writer.Exists.OpenBlock.Trim().Write(statement.Text).Trim().CloseBlock.Flush(); } } return(writer.ToString()); }
private static string BuildProjection(Projection projection, IEntityMapping mapping, IDictionary <string, object> parameters) { var projectionStatement = ProjectionWriter <TEntity> .CreateStatement(projection, mapping); parameters.AddRange(projectionStatement.Parameters); return(projectionStatement.Text); }
/// <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; }
internal static List <T> Execute(string tableName, IEntityMapping <T> entityMapping) { StringBuilder query = new StringBuilder(); query.Append($"SELECT * FROM {tableName}"); return(SqlCommandExecuteQueryForSelect <T> .Execute(query.ToString(), entityMapping)); }
protected override Expression VisitEntity(EntityExpression entity) { if (this.entity == null) { this.entity = entity.Entity; } return(entity); }
/// <summary>Read in implicit feedback data from a file</summary> /// <param name="filename">name of the file to be read from, "-" if STDIN</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(string filename, IEntityMapping user_mapping, IEntityMapping item_mapping) { if (filename.Equals("-")) return Read(Console.In, user_mapping, item_mapping); else using ( var reader = new StreamReader(filename) ) return Read(reader, user_mapping, item_mapping); }
public void Init() { for (int i = 0; i < _entityMappings.Count; i++) { IEntityMapping entityMapping = _entityMappings[i]; entityMapping.Map(); } }
private IMemberMapping GetMemberMapping(Type type, string memberName, IEntityMapping entity) { MemberInfo member = type.GetMember(memberName).FirstOrDefault(); ColumnAttribute column = member.GetCustomAttributes <ColumnAttribute>().FirstOrDefault(); return(new MemberMapping(member, column, entity)); }
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>Read in static rating data from a file</summary> /// <param name="filename">the name of the file to read from, "-" if STDIN</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(string filename, IEntityMapping user_mapping, IEntityMapping item_mapping, RatingType rating_type) { int size = 0; using ( var reader = new StreamReader(filename) ) while (reader.ReadLine() != null) size++; using ( var reader = new StreamReader(filename) ) return Read(reader, size, user_mapping, item_mapping, rating_type); }
/// <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); }
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; }
/// <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); }
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(";") }; }
// TODO as soon as we drop support for Mono 2.6, use default arguments /// <summary>Rate a given set of instances and write it to a TextWriter</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="writer">the TextWriter to write the predictions to</param> public static void WritePredictions( IRatingPredictor recommender, IRatings ratings, IEntityMapping user_mapping, IEntityMapping item_mapping, string line_format, TextWriter writer) { for (int index = 0; index < ratings.Count; index++) writer.WriteLine(line_format, user_mapping.ToOriginalID(ratings.Users[index]), item_mapping.ToOriginalID(ratings.Items[index]), recommender.Predict(ratings.Users[index], ratings.Items[index]).ToString(CultureInfo.InvariantCulture)); }
/// <summary>Read in 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="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, bool ignore_first_line = false) { if (!(user_mapping is EntityMapping) && !(item_mapping is EntityMapping) && File.Exists(filename + ".bin.Ratings")) return (IRatings) FileSerializer.Deserialize(filename + ".bin.Ratings"); return Wrap.FormatException<IRatings>(filename, delegate() { using ( var reader = new StreamReader(filename) ) { var ratings = (Ratings) Read(reader, user_mapping, item_mapping); if (!(user_mapping is EntityMapping) && !(item_mapping is EntityMapping)) ratings.Serialize(filename + ".bin.Ratings"); return ratings; } }); }
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 rating data which will be interpreted as implicit feedback data from a file</summary> /// <param name="filename">name of the file 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(string filename, float rating_threshold, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null, bool ignore_first_line = false) { string binary_filename = string.Format(CultureInfo.InvariantCulture, "{0}.bin.PosOnlyFeedbackThreshold-{1}", filename, rating_threshold); 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, rating_threshold, user_mapping, item_mapping); if (FileSerializer.Should(user_mapping, item_mapping) && FileSerializer.CanWrite(binary_filename)) feedback_data.Serialize(binary_filename); return (IPosOnlyFeedback) feedback_data; } }); }
/// <summary>Read in rating data from a file</summary> /// <param name="filename">the name of the file to read from, "-" if STDIN</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(string filename, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null) { string binary_filename = filename + ".bin.TimedRatings"; if (FileSerializer.Should(user_mapping, item_mapping) && File.Exists(binary_filename)) return (ITimedRatings) FileSerializer.Deserialize(binary_filename); return Wrap.FormatException<ITimedRatings>(filename, delegate() { using ( var reader = new StreamReader(filename) ) { var ratings = (TimedRatings) Read(reader, user_mapping, item_mapping); if (FileSerializer.Should(user_mapping, item_mapping) && FileSerializer.CanWrite(binary_filename)) ratings.Serialize(binary_filename); return ratings; } }); }
/// <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; }
/// <summary>Write item predictions (scores) to a TextWriter object</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="writer">the <see cref="TextWriter"/> to write to</param> /// <param name="users">a list of users to make recommendations for; if null, all users in train will be provided with recommendations</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, TextWriter writer, System.Collections.Generic.IList<int> users = null, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null) { if (users == null) users = new List<int>(train.AllUsers); foreach (int user_id in users) { var ignore_items = train.UserMatrix[user_id]; WritePredictions(recommender, user_id, candidate_items, ignore_items, num_predictions, writer, user_mapping, item_mapping); } }
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); }
/// <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> /// <param name="ignore_first_line">if true, ignore the first line</param> /// <returns>the rating data</returns> public static IRatings Read( TextReader reader, int size, IEntityMapping user_mapping = null, IEntityMapping item_mapping = null, RatingType rating_type = RatingType.FLOAT, 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(); IRatings ratings; if (rating_type == RatingType.BYTE) ratings = new StaticByteRatings(size); else if (rating_type == RatingType.FLOAT) ratings = new StaticRatings(size); else throw new FormatException(string.Format("Unknown rating type: {0}", rating_type)); 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); } ratings.InitScale(); 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 IRatings Read(TextReader reader, IEntityMapping user_mapping, IEntityMapping item_mapping) { var ratings = new Ratings(); var separators = new string[] { "::" }; string line; while ( (line = reader.ReadLine()) != null ) { string[] tokens = line.Split(separators, StringSplitOptions.None); 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 binary attribute data from a StreamReader</summary> /// <remarks> /// The expected (sparse) line format is: /// ENTITY_ID tab/space/comma ATTRIBUTE_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 attribute data</returns> public static SparseBooleanMatrix Read(StreamReader reader, IEntityMapping mapping) { var matrix = new SparseBooleanMatrix(); string line; while ((line = reader.ReadLine()) != null) { // ignore empty lines if (line.Length == 0) continue; string[] tokens = line.Split(Constants.SPLIT_CHARS); if (tokens.Length != 2) throw new FormatException("Expected exactly 2 columns: " + line); int entity_id = mapping.ToInternalID(tokens[0]); int attr_id = int.Parse(tokens[1]); matrix[entity_id, attr_id] = true; } return matrix; }