/// <summary> /// Creates the command processor. /// </summary> /// <param name="session">The session.</param> /// <param name="connection">The connection.</param> /// <returns>Created command processor.</returns> public CommandProcessor CreateCommandProcessor(Session session, SqlConnection connection) { var configuration = session.Configuration; var useBatches = configuration.BatchSize > 1 && providerInfo.Supports(ProviderFeatures.DmlBatches); var useCursorParameters = providerInfo.Supports(ProviderFeatures.MultipleResultsViaCursorParameters); var factory = useCursorParameters ? new CursorCommandFactory(driver, session, connection) : new CommandFactory(driver, session, connection); var processor = useBatches ? new BatchingCommandProcessor(factory, configuration.BatchSize, session.Domain.StorageProviderInfo.MaxQueryParameterCount) : (CommandProcessor) new SimpleCommandProcessor(factory, session.Domain.StorageProviderInfo.MaxQueryParameterCount); return(processor); }
// Constructors public ExpressionProcessor( LambdaExpression lambda, HandlerAccessor handlers, SqlCompiler compiler, params IReadOnlyList <SqlExpression>[] sourceColumns) { ArgumentValidator.EnsureArgumentNotNull(lambda, "lambda"); ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers"); ArgumentValidator.EnsureArgumentNotNull(sourceColumns, "sourceColumns"); this.compiler = compiler; // This might be null, check before use! this.lambda = lambda; this.sourceColumns = sourceColumns; providerInfo = handlers.ProviderInfo; driver = handlers.StorageDriver; fixBooleanExpressions = !providerInfo.Supports(ProviderFeatures.FullFeaturedBooleanExpressions); emptyStringIsNull = providerInfo.Supports(ProviderFeatures.TreatEmptyStringAsNull); dateTimeEmulation = providerInfo.Supports(ProviderFeatures.DateTimeEmulation); dateTimeOffsetEmulation = providerInfo.Supports(ProviderFeatures.DateTimeOffsetEmulation); memberCompilerProvider = handlers.DomainHandler.GetMemberCompilerProvider <SqlExpression>(); specialByteArrayComparison = providerInfo.ProviderName.Equals(WellKnown.Provider.Oracle); bindings = new HashSet <QueryParameterBinding>(); activeParameters = new List <ParameterExpression>(); evaluator = new ExpressionEvaluator(lambda); parameterExtractor = new ParameterExtractor(evaluator); if (fixBooleanExpressions) { booleanExpressionConverter = new BooleanExpressionConverter(driver); } if (lambda.Parameters.Count != sourceColumns.Length) { throw Exceptions.InternalError(Strings.ExParametersCountIsNotSameAsSourceColumnListsCount, OrmLog.Instance); } if (sourceColumns.Any(list => list.Any(c => c.IsNullReference()))) { throw Exceptions.InternalError(Strings.ExSourceColumnListContainsNullValues, OrmLog.Instance); } sourceMapping = new Dictionary <ParameterExpression, IReadOnlyList <SqlExpression> >(); }
internal ICollection <PersistRequest> Build(StorageNode node, PersistRequestBuilderTask task) { var context = new PersistRequestBuilderContext(task, node.Mapping, node.Configuration); List <PersistRequest> result; switch (task.Kind) { case PersistRequestKind.Insert: result = BuildInsertRequest(context); break; case PersistRequestKind.Remove: result = BuildRemoveRequest(context); break; case PersistRequestKind.Update: result = BuildUpdateRequest(context); break; default: throw new ArgumentOutOfRangeException("task.Kind"); } // Merging requests for servers which support batching // unless version validation is requested. if (providerInfo.Supports(ProviderFeatures.Batches) && result.Count > 1 && !task.ValidateVersion) { var batch = SqlDml.Batch(); var bindings = new HashSet <PersistParameterBinding>(); foreach (var request in result) { batch.Add(request.Statement); bindings.UnionWith(request.ParameterBindings); } var batchRequest = CreatePersistRequest(batch, bindings, node.Configuration); batchRequest.Prepare(); return(new List <PersistRequest> { batchRequest }.AsReadOnly()); } foreach (var item in result) { item.Prepare(); } return(result.AsReadOnly()); }
// Constructors /// <summary> /// Initializes a new instance of this class. /// </summary> public SqlCompiler(HandlerAccessor handlers, CompilerConfiguration configuration) { Handlers = handlers; OuterReferences = new BindingCollection <ApplyParameter, Pair <SqlProvider, bool> >(); Mapping = configuration.StorageNode.Mapping; TypeIdRegistry = configuration.StorageNode.TypeIdRegistry; NodeConfiguration = configuration.StorageNode.Configuration; providerInfo = Handlers.ProviderInfo; temporaryTablesSupported = DomainHandler.TemporaryTableManager.Supported; if (!providerInfo.Supports(ProviderFeatures.FullFeaturedBooleanExpressions)) { booleanExpressionConverter = new BooleanExpressionConverter(Driver); } stubColumnMap = new Dictionary <SqlColumnStub, SqlExpression>(); }
/// <inheritdoc/> protected override SqlProvider VisitJoin(JoinProvider provider) { var left = Compile(provider.Left); var right = Compile(provider.Right); // SQLite does not allow certain join combinations // Any right part of join expression should not be join itself // See IssueA363_WrongInnerJoin for example of such query var strictJoinWorkAround = providerInfo.Supports(ProviderFeatures.StrictJoinSyntax) && right.Request.Statement.From is SqlJoinedTable; var leftShouldUseReference = ShouldUseQueryReference(provider, left); var leftTable = leftShouldUseReference ? left.PermanentReference : left.Request.Statement.From; var leftColumns = leftShouldUseReference ? leftTable.Columns.Cast <SqlColumn>() : left.Request.Statement.Columns; var leftExpressions = leftShouldUseReference ? leftTable.Columns.Cast <SqlExpression>().ToList() : ExtractColumnExpressions(left.Request.Statement); var rightShouldUseReference = strictJoinWorkAround || ShouldUseQueryReference(provider, right); var rightTable = rightShouldUseReference ? right.PermanentReference : right.Request.Statement.From; var rightColumns = rightShouldUseReference ? rightTable.Columns.Cast <SqlColumn>() : right.Request.Statement.Columns; var rightExpressions = rightShouldUseReference ? rightTable.Columns.Cast <SqlExpression>().ToList() : ExtractColumnExpressions(right.Request.Statement); var joinType = provider.JoinType == JoinType.LeftOuter ? SqlJoinType.LeftOuterJoin : SqlJoinType.InnerJoin; SqlExpression joinExpression = null; for (var i = 0; i < provider.EqualIndexes.Count(); ++i) { var leftExpression = leftExpressions[provider.EqualIndexes[i].First]; var rightExpression = rightExpressions[provider.EqualIndexes[i].Second]; joinExpression &= GetJoinExpression(leftExpression, rightExpression, provider, i); } var joinedTable = SqlDml.Join( joinType, leftTable, rightTable, leftColumns.ToList(), rightColumns.ToList(), joinExpression); var query = SqlDml.Select(joinedTable); if (!leftShouldUseReference) { query.Where &= left.Request.Statement.Where; } if (!rightShouldUseReference) { query.Where &= right.Request.Statement.Where; } query.Columns.AddRange(joinedTable.AliasedColumns); return(CreateProvider(query, provider, left, right)); }
public void Visit(SqlSelect node) { foreach (var column in node.Columns) { Visit(column); } foreach (var column in node.GroupBy) { Visit(column); } foreach (var column in node.OrderBy) { Visit(column); } if (node.From != null) { Visit(node.From); } if (!node.Having.IsNullReference()) { Visit(node.Having); } if (!node.Limit.IsNullReference()) { Visit(node.Limit); } if (!node.Offset.IsNullReference()) { Visit(node.Offset); } if (!node.Where.IsNullReference()) { Visit(node.Where); } foreach (var hint in node.Hints) { Visit(hint); } if (node.Columns.Count == 0) { node.Columns.Add(SqlDml.Null, "NULL"); } var hasPaging = node.HasLimit || node.HasOffset; var keepOrderBy = ReferenceEquals(node, rootSelect) || hasPaging; if (!keepOrderBy) { node.OrderBy.Clear(); } var addOrderBy = hasPaging && node.OrderBy.Count == 0 && providerInfo.Supports(ProviderFeatures.PagingRequiresOrderBy); if (addOrderBy) { node.OrderBy.Add(1); } }