protected override void PrepareCommand(Row row, SqlCommand command)
        {
            var fields = _entity.OutputFields();
            var writer = new FieldSqlWriter(fields).AddDeleted(_entity);
            var sets   = writer.Alias(_connection.L, _connection.R).SetParam().Write(", ", false);

            command.CommandText = string.Format(@"
                UPDATE [{0}]
                SET {1}, TflBatchId = @TflBatchId
                WHERE TflKey = @TflKey;
            ", _entity.OutputName(), sets);

            foreach (var field in fields)
            {
                AddParameter(command, field.Identifier, row[field.Alias]);
            }
            if (_entity.Delete)
            {
                AddParameter(command, "TflDeleted", false);
            }
            AddParameter(command, "TflKey", row["TflKey"]);
            AddParameter(command, "TflBatchId", _entity.TflBatchId);

            Logger.EntityDebug(_entity.Alias, command.CommandText);
        }
        public DapperBulkUpdateOperation(AbstractConnection connection, Entity entity)
        {
            _connection = connection;
            _tflBatchId = entity.TflBatchId;
            _fields     = entity.OutputFields();
            var writer = new FieldSqlWriter(_fields);
            var sets   = writer.Alias(_connection.L, _connection.R).SetParam().Write(", ", false);

            _sql = string.Format(@"UPDATE [{0}] SET {1}, TflBatchId = @TflBatchId WHERE TflKey = @TflKey;", entity.OutputName(), sets);
        }
Example #3
0
        public static Dictionary <string, KeyValuePair <Field, SearchType> > CreateFieldMap(Entity entity)
        {
            var fields = new Dictionary <string, KeyValuePair <Field, SearchType> >();

            foreach (var field in entity.OutputFields())
            {
                foreach (var searchType in field.SearchTypes)
                {
                    if (fields.ContainsKey(field.Alias))
                    {
                        fields[field.Alias + searchType.Name] = new KeyValuePair <Field, SearchType>(field, searchType);
                    }
                    else
                    {
                        fields[field.Alias] = new KeyValuePair <Field, SearchType>(field, searchType);
                    }
                }
            }
            if (!fields.ContainsKey("TflBatchId"))
            {
                fields.Add("TflBatchId", new KeyValuePair <Field, SearchType>(new Field("int", "0", FieldType.None, true, "0")
                {
                    Name = "tflbatchid"
                }, new SearchType()
                {
                    Analyzer = "keyword", Index = true, MultiValued = false, Name = "keyword", Store = true
                }));
            }
            if (entity.Delete && !fields.ContainsKey("TflDeleted"))
            {
                fields.Add("TflDeleted", new KeyValuePair <Field, SearchType>(new Field("boolean", "false", FieldType.None, true, "0")
                {
                    Name = "tfldeleted"
                }, new SearchType()
                {
                    Analyzer = "keyword", Index = true, MultiValued = false, Name = "keyword", Store = true
                }));
            }
            return(fields);
        }
Example #4
0
        private static Dictionary <string, Analyzer> GetFields(Entity entity, string version, ILogger logger)
        {
            var fields = new Dictionary <string, Analyzer>();

            foreach (var field in entity.OutputFields())
            {
                foreach (var searchType in field.SearchTypes)
                {
                    if (Analyzers.Contains(searchType.Analyzer))
                    {
                        if (fields.ContainsKey(field.Alias))
                        {
                            fields[field.Alias + searchType.Name] = LuceneAnalyzerFactory.Create(searchType.Analyzer, version);
                        }
                        else
                        {
                            fields[field.Alias] = LuceneAnalyzerFactory.Create(searchType.Analyzer, version);
                        }
                    }
                    else
                    {
                        logger.EntityWarn(entity.Name, "Analyzer '{0}' specified in search type '{1}' is not supported.  Lucene is limited to standard, simple, keyword, or whitespace.", searchType.Analyzer, searchType.Name);
                        if (!fields.ContainsKey(field.Alias))
                        {
                            fields[field.Alias] = LuceneAnalyzerFactory.Create(searchType.Analyzer, version);
                        }
                    }
                }
            }
            if (!fields.ContainsKey("TflBatchId"))
            {
                fields.Add("TflBatchId", new KeywordAnalyzer());
            }
            if (entity.Delete && !fields.ContainsKey("TflDeleted"))
            {
                fields.Add("TflDeleted", new KeywordAnalyzer());
            }
            return(fields);
        }
 public Dictionary<string, object> GetFields(Entity entity) {
     var fields = new Dictionary<string, object>();
     foreach (Field field in entity.OutputFields()) {
         var alias = field.Alias.ToLower();
         var type = _types.ContainsKey(field.SimpleType) ? _types[field.SimpleType] : field.SimpleType;
         if (type.Equals("string")) {
             foreach (var searchType in field.SearchTypes) {
                 var analyzer = searchType.Analyzer.ToLower();
                 if (_analyzers.Contains(analyzer)) {
                     if (fields.ContainsKey(alias)) {
                         fields[alias + searchType.Name.ToLower()] = new Dictionary<string, object>() { { "type", type }, { "analyzer", analyzer } };
                     } else {
                         if (analyzer.Equals(string.Empty)) {
                             fields[alias] = new Dictionary<string, object>() { { "type", type } };
                         } else {
                             fields[alias] = new Dictionary<string, object>() { { "type", type }, { "analyzer", analyzer } };
                         }
                     }
                 } else {
                     _logger.EntityWarn(entity.Name, "Analyzer '{0}' specified in search type '{1}' is not supported.  Please use a built-in analyzer for Solr.", analyzer, searchType.Name);
                     if (!fields.ContainsKey(alias)) {
                         fields[alias] = new Dictionary<string, object>() { { "type", type } };
                     }
                 }
             }
         } else {
             fields[alias] = new Dictionary<string, object>() { { "type", type } };
         }
     }
     if (!fields.ContainsKey("tflbatchid")) {
         fields.Add("tflbatchid", new Dictionary<string, object> { { "type", "long" } });
     }
     if (!fields.ContainsKey("tfldeleted")) {
         fields.Add("tfldeleted", new Dictionary<string, object> { { "type", "boolean" } });
     }
     return fields;
 }
        public Dictionary <string, string> GetFieldMap(Entity entity)
        {
            var map = new Dictionary <string, string>();

            foreach (Field field in entity.OutputFields())
            {
                var alias = field.Alias.ToLower();
                if (field.SimpleType.Equals("string"))
                {
                    foreach (var searchType in field.SearchTypes)
                    {
                        if (map.ContainsKey(alias))
                        {
                            map[alias + searchType.Name.ToLower()] = alias;
                        }
                        else
                        {
                            map[alias] = alias;
                        }
                    }
                }
                else
                {
                    map[alias] = alias;
                }
            }
            if (!map.ContainsKey("tflbatchid"))
            {
                map.Add("tflbatchid", "tflbatchid");
            }
            if (!map.ContainsKey("tfldeleted"))
            {
                map.Add("tfldeleted", "tfldeleted");
            }
            return(map);
        }
 public Dictionary<string, string> GetFieldMap(Entity entity) {
     var map = new Dictionary<string, string>();
     foreach (Field field in entity.OutputFields()) {
         var alias = field.Alias.ToLower();
         if (field.SimpleType.Equals("string")) {
             foreach (var searchType in field.SearchTypes) {
                 if (map.ContainsKey(alias)) {
                     map[alias + searchType.Name.ToLower()] = alias;
                 } else {
                     map[alias] = alias;
                 }
             }
         } else {
             map[alias] = alias;
         }
     }
     if (!map.ContainsKey("tflbatchid")) {
         map.Add("tflbatchid", "tflbatchid");
     }
     if (!map.ContainsKey("tfldeleted")) {
         map.Add("tfldeleted", "tfldeleted");
     }
     return map;
 }
        public Dictionary <string, object> GetFields(Entity entity)
        {
            var fields = new Dictionary <string, object>();

            foreach (Field field in entity.OutputFields())
            {
                var alias = field.Alias.ToLower();
                var type  = _types.ContainsKey(field.SimpleType) ? _types[field.SimpleType] : field.SimpleType;
                if (type.Equals("string"))
                {
                    foreach (var searchType in field.SearchTypes)
                    {
                        var analyzer = searchType.Analyzer.ToLower();
                        if (_analyzers.Contains(analyzer))
                        {
                            if (fields.ContainsKey(alias))
                            {
                                fields[alias + searchType.Name.ToLower()] = new Dictionary <string, object>()
                                {
                                    { "type", type }, { "analyzer", analyzer }
                                };
                            }
                            else
                            {
                                if (analyzer.Equals(string.Empty))
                                {
                                    fields[alias] = new Dictionary <string, object>()
                                    {
                                        { "type", type }
                                    };
                                }
                                else
                                {
                                    fields[alias] = new Dictionary <string, object>()
                                    {
                                        { "type", type }, { "analyzer", analyzer }
                                    };
                                }
                            }
                        }
                        else
                        {
                            _logger.EntityWarn(entity.Name, "Analyzer '{0}' specified in search type '{1}' is not supported.  Please use a built-in analyzer for Solr.", analyzer, searchType.Name);
                            if (!fields.ContainsKey(alias))
                            {
                                fields[alias] = new Dictionary <string, object>()
                                {
                                    { "type", type }
                                };
                            }
                        }
                    }
                }
                else
                {
                    fields[alias] = new Dictionary <string, object>()
                    {
                        { "type", type }
                    };
                }
            }
            if (!fields.ContainsKey("tflbatchid"))
            {
                fields.Add("tflbatchid", new Dictionary <string, object> {
                    { "type", "long" }
                });
            }
            if (!fields.ContainsKey("tfldeleted"))
            {
                fields.Add("tfldeleted", new Dictionary <string, object> {
                    { "type", "boolean" }
                });
            }
            return(fields);
        }