private DynamicTransformerCompiler AddAndCompileTransform(TransformerDefinition transformerDefinition) { var transformer = new DynamicTransformerCompiler(transformerDefinition, configuration, extensions, transformerDefinition.Name, path); var generator = transformer.GenerateInstance(); transformCache.AddOrUpdate(transformerDefinition.TransfomerId, generator, (s, viewGenerator) => generator); logger.Info("New transformer {0}:\r\n{1}\r\nCompiled to:\r\n{2}", transformer.Name, transformer.CompiledQueryText, transformer.CompiledQueryText); return(transformer); }
public static TransformerBase Compile(TransformerDefinition definition) { var cSharpSafeName = GetCSharpSafeName(definition.Name, isIndex: false); var @class = CreateClass(cSharpSafeName, definition); var compilationResult = CompileInternal(definition.Name, cSharpSafeName, @class, isIndex: false); var type = compilationResult.Type; var transformer = (TransformerBase)Activator.CreateInstance(type); transformer.Source = compilationResult.Code; return(transformer); }
private string DetermineName(TransformerDefinition transformer) { if (UseGrouping.Value == false) { return("Transformers"); } var name = transformer.Name; if (name.Contains("/") == false) { return("No Group"); } var groups = name.Split('/'); return(groups[0]); }
public Get() { using (var store = new DocumentStore()) { #region get_1_1 TransformerDefinition transformer = store .DatabaseCommands .GetTransformer("Order/Statistics"); // returns null if does not exist #endregion #region get_2_1 TransformerDefinition[] transformers = store .DatabaseCommands .GetTransformers(0, 128); #endregion } }
private void ReplicateSingleTransformer(ReplicationStrategy destination, TransformerDefinition definition) { try { var clonedTransformer = definition.Clone(); clonedTransformer.TransfomerId = 0; var url = destination.ConnectionStringOptions.Url + "/transformers/" + Uri.EscapeUriString(definition.Name) + "?" + GetDebugInformation(); var replicationRequest = HttpRavenRequestFactory.Create(url, HttpMethod.Put, destination.ConnectionStringOptions, Replication.GetRequestBuffering(destination)); replicationRequest.Write(RavenJObject.FromObject(clonedTransformer)); replicationRequest.ExecuteRequest(); } catch (Exception e) { Replication.HandleRequestBufferingErrors(e, destination); Log.WarnException("Could not replicate transformer " + definition.Name + " to " + destination.ConnectionStringOptions.Url, e); } }
public void CanSaveTransformerWithCastToDynamic() { using (var store = NewRemoteDocumentStore()) { var t1 = new TransformerDefinition { Name = "T1", TransformResults = "from people in results " + " from child in (IEnumerable<dynamic>)people.Children " + " from grandchild in (IEnumerable<dynamic>)child.Children " + " from great in (IEnumerable<dynamic>)grandchild.Children " + " select new " + " { " + " Name = child.Name " + " }" }; store.DatabaseCommands.PutTransformer("T1", t1); } }
public void CanSaveTransformerWithMultipleSelectMany() { using (var store = NewRemoteDocumentStore()) { var t1 = new TransformerDefinition { Name = "T1", TransformResults = "from people in results " + " from child in people.Children " + " from grandchild in child.Children " + " from great in grandchild.Children " + " select new " + " { " + " Name = child.Name " + " }" }; store.DatabaseCommands.PutTransformer("T1", t1); } }
public string PutTransform(string name, TransformerDefinition definition) { if (name == null) { throw new ArgumentNullException("name"); } if (definition == null) { throw new ArgumentNullException("definition"); } name = name.Trim(); var existingDefinition = IndexDefinitionStorage.GetTransformerDefinition(name); if (existingDefinition != null && existingDefinition.Equals(definition)) { return(name); // no op for the same transformer } var generator = IndexDefinitionStorage.CompileTransform(definition); if (existingDefinition != null) { IndexDefinitionStorage.RemoveTransformer(existingDefinition.TransfomerId); } TransactionalStorage.Batch(accessor => { definition.TransfomerId = (int)Database.Documents.GetNextIdentityValueWithoutOverwritingOnExistingDocuments("TransformerId", accessor); }); IndexDefinitionStorage.CreateAndPersistTransform(definition, generator); IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition); TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() => Database.Notifications.RaiseNotifications(new TransformerChangeNotification() { Name = name, Type = TransformerChangeTypes.TransformerAdded, })); return(name); }
private static MemberDeclarationSyntax CreateClass(string name, TransformerDefinition definition) { var statements = new List <StatementSyntax>(); var methodDetector = new MethodDetectorRewriter(); statements.Add(HandleTransformResults(definition.TransformResults, methodDetector)); var methods = methodDetector.Methods; if (methods.HasGroupBy) { statements.Add(RoslynHelper.This(nameof(TransformerBase.HasGroupBy)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement()); } if (methods.HasLoadDocument) { statements.Add(RoslynHelper.This(nameof(TransformerBase.HasLoadDocument)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement()); } if (methods.HasTransformWith) { statements.Add(RoslynHelper.This(nameof(TransformerBase.HasTransformWith)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement()); } if (methods.HasInclude) { statements.Add(RoslynHelper.This(nameof(TransformerBase.HasInclude)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement()); } var ctor = RoslynHelper.PublicCtor(name).AddBodyStatements(statements.ToArray()); return(RoslynHelper.PublicClass(name) .WithBaseClass <TransformerBase>() .WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(ctor))); }
public void AddTransform(string name, TransformerDefinition definition) { var fixedName = FixupIndexName(name); transformDefinitions.AddOrUpdate(fixedName, definition, (s1, def) => definition); }
public void AddTransform(string name, TransformerDefinition definition) { transformDefinitions.AddOrUpdate(name, definition, (s1, def) => definition); }
public string PutTransformer(string name, TransformerDefinition transformerDef) { return(AsyncHelpers.RunSync(() => asyncServerClient.PutTransformerAsync(name, transformerDef))); }
public PutTransformerCommand CreateRequest(DocumentConvention documentConvention, string transformerName, TransformerDefinition transformerDefinition) { var entityToBlittable = new EntityToBlittable(null); var transformerDefinitionAsBlittable = entityToBlittable.ConvertEntityToBlittable(transformerDefinition, documentConvention, _context); return(new PutTransformerCommand() { TransformerDefinition = transformerDefinitionAsBlittable, Context = _context, TransformerName = transformerName }); }
public Task WriteTransformerAsync(TransformerDefinition transformer, CancellationToken cancellationToken) { return(_store.AsyncDatabaseCommands.PutTransformerAsync(transformer.Name, transformer, cancellationToken)); }
public string CreateTransform(TransformerDefinition transformerDefinition, AbstractTransformer transformer) { transformCache.AddOrUpdate(transformerDefinition.TransfomerId, transformer, (s, viewGenerator) => transformer); return(transformer.Name); }
public DynamicTransformerCompiler( TransformerDefinition transformerDefinition, InMemoryRavenConfiguration configuration, OrderedPartCollection <AbstractDynamicCompilationExtension> extensions, string name, string basePath) : base(configuration, extensions, name, basePath) { this.transformerDefinition = transformerDefinition; }
public bool Equals(TransformerDefinition other) { return string.Equals(TransformResults, other.TransformResults); }
public string PutTransformer(string name, TransformerDefinition transformerDef) { return(asyncServerClient.PutTransformerAsync(name, transformerDef).ResultUnwrap()); }
public Task <string> PutTransformerAsync(string name, TransformerDefinition transformerDefinition) { return(new CompletedTask <string>(databaseCommands.PutTransformer(name, transformerDefinition))); }
public string PutTransform(string name, TransformerDefinition definition) { if (name == null) { throw new ArgumentNullException("name"); } if (definition == null) { throw new ArgumentNullException("definition"); } name = name.Trim(); var existingDefinition = IndexDefinitionStorage.GetTransformerDefinition(name); if (existingDefinition != null) { switch (existingDefinition.LockMode) { case TransformerLockMode.Unlock: if (existingDefinition.Equals(definition)) { return(name); // no op for the same transformer } break; case TransformerLockMode.LockedIgnore: Log.Info("Transformer {0} not saved because it was lock (with ignore)", name); return(name); default: throw new ArgumentOutOfRangeException(); } } var generator = IndexDefinitionStorage.CompileTransform(definition); if (existingDefinition != null) { IndexDefinitionStorage.RemoveTransformer(existingDefinition.TransfomerId); } var temporary = definition.Temporary; if (temporary) { definition.TransfomerId = Database.Transformers.GetNextTemporaryTransformerIndex(); IndexDefinitionStorage.CreateTransform(definition, generator); IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition); } else { TransactionalStorage.Batch(accessor => { definition.TransfomerId = (int)Database.Documents.GetNextIdentityValueWithoutOverwritingOnExistingDocuments("TransformerId", accessor); }); IndexDefinitionStorage.CreateTransform(definition, generator); IndexDefinitionStorage.PersistTransform(definition); IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition); TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() => Database.Notifications.RaiseNotifications(new TransformerChangeNotification() { Name = name, Type = TransformerChangeTypes.TransformerAdded, })); } return(name); }
public Task WriteTransformerAsync(TransformerDefinition transformer, CancellationToken cancellationToken) { Count++; return(new CompletedTask()); }
public TransformerDefinitionModel() { ModelUrl = "/transformers/"; Transformer = new TransformerDefinition(); Errors = new ObservableCollection <TransformerDefinitionError>(); }
private void UpdateFromTransformer(TransformerDefinition transformerDefinition) { Transformer = transformerDefinition; OnEverythingChanged(); }
public string PutTransform(string name, TransformerDefinition definition, bool isReplication = false) { if (name == null) { throw new ArgumentNullException("name"); } if (definition == null) { throw new ArgumentNullException("definition"); } name = name.Trim(); var existingDefinition = IndexDefinitionStorage.GetTransformerDefinition(name); if (existingDefinition != null) { var newTransformerVersion = definition.TransformerVersion; var currentTransformerVersion = existingDefinition.TransformerVersion; // whether we update the transformer definition or not, // we need to update the transformer version existingDefinition.TransformerVersion = definition.TransformerVersion = Math.Max(currentTransformerVersion ?? 0, newTransformerVersion ?? 0); switch (isReplication) { case true: if (newTransformerVersion != null && currentTransformerVersion != null && newTransformerVersion <= currentTransformerVersion) { //this new transformer is an older version of the current one return(null); } // we need to update the lock mode only if it was updated by another server existingDefinition.LockMode = definition.LockMode; break; default: switch (existingDefinition.LockMode) { case TransformerLockMode.Unlock: if (existingDefinition.Equals(definition)) { return(name); // no op for the same transformer } definition.TransformerVersion++; break; case TransformerLockMode.LockedIgnore: Log.Info("Transformer {0} not saved because it was lock (with ignore)", name); return(name); default: throw new ArgumentOutOfRangeException(); } break; } } else if (isReplication == false) { // we're creating a new transformer, // we need to take the transformer version of the deleted transformer (if exists) definition.TransformerVersion = GetDeletedTransformerId(definition.Name); definition.TransformerVersion = (definition.TransformerVersion ?? 0) + 1; } if (definition.TransformerVersion == null) { definition.TransformerVersion = 0; } var generator = IndexDefinitionStorage.CompileTransform(definition); if (existingDefinition != null) { IndexDefinitionStorage.RemoveTransformer(existingDefinition.TransfomerId); } var temporary = definition.Temporary; if (temporary) { definition.TransfomerId = Database.Transformers.GetNextTemporaryTransformerIndex(); IndexDefinitionStorage.CreateTransform(definition, generator); IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition); } else { TransactionalStorage.Batch(accessor => { definition.TransfomerId = (int)Database.Documents.GetNextIdentityValueWithoutOverwritingOnExistingDocuments("TransformerId", accessor); }); IndexDefinitionStorage.CreateTransform(definition, generator); IndexDefinitionStorage.PersistTransform(definition); IndexDefinitionStorage.AddTransform(definition.TransfomerId, definition); TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() => Database.Notifications.RaiseNotifications(new TransformerChangeNotification() { Name = name, Type = TransformerChangeTypes.TransformerAdded, Version = definition.TransformerVersion })); } return(name); }
public bool Equals(TransformerDefinition other) { return(string.Equals(TransformResults, other.TransformResults)); }
public Task WriteTransformerAsync(TransformerDefinition transformer, CancellationToken cancellationToken) { _database.Transformers.PutTransform(transformer.Name, transformer); return(new CompletedTask()); }
public void Init(TransformerDefinition def) { transformerDefinition = def; }
public Task <HttpResponseMessage> Exploration() { var linq = GetQueryStringValue("linq"); var collection = GetQueryStringValue("collection"); int timeoutSeconds; if (int.TryParse(GetQueryStringValue("timeoutSeconds"), out timeoutSeconds) == false) { timeoutSeconds = 60; } int pageSize; if (int.TryParse(GetQueryStringValue("pageSize"), out pageSize) == false) { pageSize = 100000; } var hash = Encryptor.Current.Hash.Compute16(Encoding.UTF8.GetBytes(linq)); var sourceHashed = MonoHttpUtility.UrlEncode(Convert.ToBase64String(hash)); var transformerName = Constants.TemporaryTransformerPrefix + sourceHashed; var transformerDefinition = Database.IndexDefinitionStorage.GetTransformerDefinition(transformerName); if (transformerDefinition == null) { transformerDefinition = new TransformerDefinition { Name = transformerName, Temporary = true, TransformResults = linq }; Database.Transformers.PutTransform(transformerName, transformerDefinition); } var msg = GetEmptyMessage(); using (var cts = new CancellationTokenSource()) { var timeout = cts.TimeoutAfter(TimeSpan.FromSeconds(timeoutSeconds)); var indexQuery = new IndexQuery { PageSize = pageSize, Start = 0, Query = "Tag:" + collection, ResultsTransformer = transformerName }; var accessor = Database.TransactionalStorage.CreateAccessor(); //accessor will be disposed in the StreamQueryContent.SerializeToStreamAsync! try { var queryOp = new QueryActions.DatabaseQueryOperation(Database, "Raven/DocumentsByEntityName", indexQuery, accessor, cts); queryOp.Init(); msg.Content = new StreamQueryContent(InnerRequest, queryOp, accessor, timeout, mediaType => msg.Content.Headers.ContentType = new MediaTypeHeaderValue(mediaType) { CharSet = "utf-8" }, o => { if (o.Count == 2 && o.ContainsKey(Constants.DocumentIdFieldName) && o.ContainsKey(Constants.Metadata)) { // this is the raw value out of the server, we don't want to get that var doc = queryOp.DocRetriever.Load(o.Value <string>(Constants.DocumentIdFieldName)); var djo = doc as IDynamicJsonObject; if (djo != null) { return(djo.Inner); } } return(o); }); msg.Headers.Add("Raven-Result-Etag", queryOp.Header.ResultEtag.ToString()); msg.Headers.Add("Raven-Index-Etag", queryOp.Header.IndexEtag.ToString()); msg.Headers.Add("Raven-Is-Stale", queryOp.Header.IsStale ? "true" : "false"); msg.Headers.Add("Raven-Index", queryOp.Header.Index); msg.Headers.Add("Raven-Total-Results", queryOp.Header.TotalResults.ToString(CultureInfo.InvariantCulture)); msg.Headers.Add("Raven-Index-Timestamp", queryOp.Header.IndexTimestamp.GetDefaultRavenFormat()); if (IsCsvDownloadRequest(InnerRequest)) { msg.Content.Headers.Add("Content-Disposition", "attachment; filename=export.csv"); } } catch (Exception) { accessor.Dispose(); throw; } return(new CompletedTask <HttpResponseMessage>(msg)); } }