public static FromExpressionInfo AnalyzeFromExpression(
            Expression fromExpression,
            ISqlPreparationStage stage,
            UniqueIdentifierGenerator generator,
            IMethodCallTransformerProvider provider,
            ISqlPreparationContext context,
            Func <ITableInfo, SqlTable> tableGenerator)
        {
            ArgumentUtility.CheckNotNull("fromExpression", fromExpression);
            ArgumentUtility.CheckNotNull("stage", stage);
            ArgumentUtility.CheckNotNull("generator", generator);
            ArgumentUtility.CheckNotNull("provider", provider);
            ArgumentUtility.CheckNotNull("context", context);

            var visitor = new SqlPreparationFromExpressionVisitor(generator, stage, provider, context, tableGenerator);

            visitor.VisitExpression(fromExpression);
            if (visitor.FromExpressionInfo != null)
            {
                return(visitor.FromExpressionInfo.Value);
            }

            var message = string.Format(
                "Error parsing expression '{0}'. Expressions of type '{1}' cannot be used as the SqlTables of a from clause.",
                FormattingExpressionTreeVisitor.Format(fromExpression),
                fromExpression.Type.Name);

            throw new NotSupportedException(message);
        }
        private SubStatementWithRowNumber CreateSubStatementWithRowNumber(
            SqlStatementBuilder sqlStatementBuilder,
            UniqueIdentifierGenerator generator,
            ISqlPreparationStage stage,
            ISqlPreparationContext context)
        {
            var originalSelectProjection = sqlStatementBuilder.SelectProjection;

            IncludeRowNumberInSelectProjection(sqlStatementBuilder, stage, context);

            // Orderings are not allowed in SQL substatements unless a TOP expression is present
            if (sqlStatementBuilder.TopExpression == null)
            {
                sqlStatementBuilder.Orderings.Clear();
            }

            sqlStatementBuilder.RecalculateDataInfo(originalSelectProjection);
            // No NamedExpression required here because the row number tuple's items already have named members
            var newSqlStatement = sqlStatementBuilder.GetStatementAndResetBuilder();

            var tableInfo = new ResolvedSubStatementTableInfo(generator.GetUniqueIdentifier("q"), newSqlStatement);
            var sqlTable  = new SqlTable(tableInfo, JoinSemantics.Inner);

            var originalProjectionSelector = Expression.MakeMemberAccess(
                new SqlTableReferenceExpression(sqlTable),
                newSqlStatement.SelectProjection.Type.GetProperty("Key"));
            var rowNumberSelector = Expression.MakeMemberAccess(
                new SqlTableReferenceExpression(sqlTable),
                newSqlStatement.SelectProjection.Type.GetProperty("Value"));

            return(new SubStatementWithRowNumber(sqlTable, originalProjectionSelector, rowNumberSelector));
        }
    public static Expression ResolveExpression (
        Expression expression,
        IMappingResolver resolver,
        IMappingResolutionStage stage,
        IMappingResolutionContext context,
        UniqueIdentifierGenerator generator)
    {
      ArgumentUtility.CheckNotNull ("expression", expression);
      ArgumentUtility.CheckNotNull ("resolver", resolver);
      ArgumentUtility.CheckNotNull ("stage", stage);
      ArgumentUtility.CheckNotNull ("context", context);
      ArgumentUtility.CheckNotNull ("generator", generator);

      var entityIdentityResolver = new EntityIdentityResolver (stage, resolver, context);
      var comparisonSplitter = new CompoundExpressionComparisonSplitter();
      var namedExpressionCombiner = new NamedExpressionCombiner (context);
      var groupAggregateSimplifier = new GroupAggregateSimplifier (stage, context);

      var visitor1 = new ResolvingExpressionVisitor (
          resolver, stage, context, generator, entityIdentityResolver, comparisonSplitter, namedExpressionCombiner, groupAggregateSimplifier, false);
      var result1 = visitor1.VisitExpression (expression);

      var visitor2 = new ResolvingExpressionVisitor (
          resolver, stage, context, generator, entityIdentityResolver, comparisonSplitter, namedExpressionCombiner, groupAggregateSimplifier, true);
      var result2 = visitor2.VisitExpression (result1);
      return result2;
    }
Beispiel #4
0
        private static void AppendCreateTableScript(StringBuilder sb, Type type)
        {
            var mappingResolver = new MappingResolverStub();
            var generator       = new UniqueIdentifierGenerator();
            var tableInfo       = (ResolvedSimpleTableInfo)mappingResolver.ResolveTableInfo(new UnresolvedTableInfo(type), generator);
            var entity          = mappingResolver.ResolveSimpleTableInfo(tableInfo, generator);

            var columnDeclarations = from c in entity.Columns
                                     let sqlTypeName = GetColumnType(c)
                                                       select string.Format("[{0}] {1}", c.ColumnName, sqlTypeName);

            var    primaryKeyColumns    = entity.Columns.Where(c => c.IsPrimaryKey).Select(c => c.ColumnName).ToArray();
            string primaryKeyConstraint = "";

            if (primaryKeyColumns.Length > 0)
            {
                primaryKeyConstraint = string.Format(
                    " CONSTRAINT PK_{0} PRIMARY KEY ({1})", tableInfo.TableName.Replace(".", "_"), string.Join(",", primaryKeyColumns));
            }

            sb.AppendFormat(
                "CREATE TABLE [{0}]{1}({1}{2}{1} {3})",
                tableInfo.TableName,
                Environment.NewLine,
                string.Join("," + Environment.NewLine, columnDeclarations.Select(c => "  " + c)),
                primaryKeyConstraint);
            sb.AppendLine();
        }
        public static Expression ResolveExpression(
            Expression expression,
            IMappingResolver resolver,
            IMappingResolutionStage stage,
            IMappingResolutionContext context,
            UniqueIdentifierGenerator generator)
        {
            ArgumentUtility.CheckNotNull("expression", expression);
            ArgumentUtility.CheckNotNull("resolver", resolver);
            ArgumentUtility.CheckNotNull("stage", stage);
            ArgumentUtility.CheckNotNull("context", context);
            ArgumentUtility.CheckNotNull("generator", generator);

            var entityIdentityResolver   = new EntityIdentityResolver(stage, resolver, context);
            var comparisonSplitter       = new CompoundExpressionComparisonSplitter();
            var namedExpressionCombiner  = new NamedExpressionCombiner(context);
            var groupAggregateSimplifier = new GroupAggregateSimplifier(stage, context);

            var visitor1 = new ResolvingExpressionVisitor(
                resolver, stage, context, generator, entityIdentityResolver, comparisonSplitter, namedExpressionCombiner, groupAggregateSimplifier, false);
            var result1 = visitor1.Visit(expression);

            var visitor2 = new ResolvingExpressionVisitor(
                resolver, stage, context, generator, entityIdentityResolver, comparisonSplitter, namedExpressionCombiner, groupAggregateSimplifier, true);
            var result2 = visitor2.Visit(result1);

            return(result2);
        }
 public void SetUp()
 {
   _generator = new UniqueIdentifierGenerator();
   _mappingResolver = new MappingResolver (new AttributeMappingSource().GetModel (typeof (DataContextTestClass)));
   _unmappedInfo = _unmappedType.GetProperty ("GUID");
   new AttributeMappingSource().GetModel (typeof (DataContextTestClass));
 }
Beispiel #7
0
        public override void HandleResultOperator(
            TakeResultOperator resultOperator,
            SqlStatementBuilder sqlStatementBuilder,
            UniqueIdentifierGenerator generator,
            ISqlPreparationStage stage,
            ISqlPreparationContext context)
        {
            EnsureNoTopExpression(sqlStatementBuilder, generator, stage, context);
            EnsureNoGroupExpression(sqlStatementBuilder, generator, stage, context);
            UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);

            var preparedTopExpression = stage.PrepareTopExpression(resultOperator.Count, context);

            if (sqlStatementBuilder.RowNumberSelector != null)
            {
                var whereCondition = Expression.LessThanOrEqual(
                    sqlStatementBuilder.RowNumberSelector,
                    Expression.Add(sqlStatementBuilder.CurrentRowNumberOffset, preparedTopExpression));
                sqlStatementBuilder.AddWhereCondition(whereCondition);
            }
            else
            {
                var topExpressionAsConstantExpression = preparedTopExpression as ConstantExpression;
                if (topExpressionAsConstantExpression != null)
                {
                    sqlStatementBuilder.TopExpression = new SqlLiteralExpression((int)topExpressionAsConstantExpression.Value);
                }
                else
                {
                    sqlStatementBuilder.TopExpression = preparedTopExpression;
                }
            }
        }
 public void SetUp()
 {
     _generator       = new UniqueIdentifierGenerator();
     _mappingResolver = new MappingResolver(new AttributeMappingSource().GetModel(typeof(DataContextTestClass)));
     _unmappedInfo    = _unmappedType.GetProperty("GUID");
     new AttributeMappingSource().GetModel(typeof(DataContextTestClass));
 }
Beispiel #9
0
        public override void HandleResultOperator(
            GroupResultOperator resultOperator,
            SqlStatementBuilder sqlStatementBuilder,
            UniqueIdentifierGenerator generator,
            ISqlPreparationStage stage,
            ISqlPreparationContext context)
        {
            ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
            ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
            ArgumentUtility.CheckNotNull("generator", generator);
            ArgumentUtility.CheckNotNull("stage", stage);
            ArgumentUtility.CheckNotNull("context", context);

            EnsureNoTopExpression(sqlStatementBuilder, generator, stage, context);
            EnsureNoGroupExpression(sqlStatementBuilder, generator, stage, context);
            EnsureNoDistinctQuery(sqlStatementBuilder, generator, stage, context);
            UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);

            var preparedKeySelector = stage.PrepareResultOperatorItemExpression(resultOperator.KeySelector, context);

            preparedKeySelector = HandlePotentialConstantExpression(preparedKeySelector);
            preparedKeySelector = HandlePotentialSubStatementExpression(preparedKeySelector, sqlStatementBuilder, generator);

            var preparedElementSelector = stage.PrepareResultOperatorItemExpression(resultOperator.ElementSelector, context);

            sqlStatementBuilder.GroupByExpression = preparedKeySelector;
            sqlStatementBuilder.SelectProjection  = SqlGroupingSelectExpression.CreateWithNames(preparedKeySelector, preparedElementSelector);
        }
        private SqlCommandData GenerateSqlCommand(QueryModel queryModel)
        {
            ISqlPreparationContext    preparationContext       = new SqlPreparationContext(new SqlStatementBuilder());
            IMappingResolutionContext mappingResolutionContext = new MappingResolutionContext();

            var generator         = new UniqueIdentifierGenerator();
            var preparationStage  = new DefaultSqlPreparationStage(_methodCallTransformerProvider, _resultOperatorHandlerRegistry, generator);
            var preparedStatement = preparationStage.PrepareSqlStatement(queryModel, preparationContext);

            var resolutionStage   = new DefaultMappingResolutionStage(_mappingResolver, generator);
            var resolvedStatement = resolutionStage.ResolveSqlStatement(preparedStatement, mappingResolutionContext);

            var builder         = new SqlCommandBuilder();
            var generationStage = new DefaultSqlGenerationStage();

            generationStage.GenerateTextForOuterSqlStatement(builder, resolvedStatement);

            var command = builder.GetCommand();

            if (_showQuery)
            {
                Console.WriteLine(command.CommandText);
                Console.WriteLine(string.Join(", ", command.Parameters.Select(p => p.Name + "=" + p.Value)));
                Console.WriteLine(command.GetInMemoryProjection <object>());
            }
            return(command);
        }
        protected ResolvingExpressionVisitor(
            IMappingResolver resolver,
            IMappingResolutionStage stage,
            IMappingResolutionContext context,
            UniqueIdentifierGenerator generator,
            IEntityIdentityResolver entityIdentityResolver,
            ICompoundExpressionComparisonSplitter compoundComparisonSplitter,
            INamedExpressionCombiner namedExpressionCombiner,
            IGroupAggregateSimplifier groupAggregateSimplifier,
            bool resolveEntityRefMemberExpressions)
        {
            ArgumentUtility.CheckNotNull("resolver", resolver);
            ArgumentUtility.CheckNotNull("stage", stage);
            ArgumentUtility.CheckNotNull("context", context);
            ArgumentUtility.CheckNotNull("generator", generator);
            ArgumentUtility.CheckNotNull("entityIdentityResolver", entityIdentityResolver);
            ArgumentUtility.CheckNotNull("compoundComparisonSplitter", compoundComparisonSplitter);
            ArgumentUtility.CheckNotNull("namedExpressionCombiner", namedExpressionCombiner);
            ArgumentUtility.CheckNotNull("groupAggregateSimplifier", groupAggregateSimplifier);

            _resolver  = resolver;
            _stage     = stage;
            _context   = context;
            _generator = generator;
            _entityIdentityResolver     = entityIdentityResolver;
            _compoundComparisonSplitter = compoundComparisonSplitter;
            _namedExpressionCombiner    = namedExpressionCombiner;
            _groupAggregateSimplifier   = groupAggregateSimplifier;

            _resolveEntityRefMemberExpressions = resolveEntityRefMemberExpressions;
        }
    public static FromExpressionInfo AnalyzeFromExpression (
        Expression fromExpression,
        ISqlPreparationStage stage,
        UniqueIdentifierGenerator generator,
        IMethodCallTransformerProvider provider,
        ISqlPreparationContext context,
        Func<ITableInfo, SqlTable> tableGenerator)
    {
      ArgumentUtility.CheckNotNull ("fromExpression", fromExpression);
      ArgumentUtility.CheckNotNull ("stage", stage);
      ArgumentUtility.CheckNotNull ("generator", generator);
      ArgumentUtility.CheckNotNull ("provider", provider);
      ArgumentUtility.CheckNotNull ("context", context);

      var visitor = new SqlPreparationFromExpressionVisitor (generator, stage, provider, context, tableGenerator);
      visitor.VisitExpression (fromExpression);
      if (visitor.FromExpressionInfo != null)
        return visitor.FromExpressionInfo.Value;

      var message = string.Format (
          "Error parsing expression '{0}'. Expressions of type '{1}' cannot be used as the SqlTables of a from clause.",
          FormattingExpressionTreeVisitor.Format (fromExpression),
          fromExpression.Type.Name);
      throw new NotSupportedException (message);
    }
        public override void HandleResultOperator(
            T resultOperator,
            SqlStatementBuilder sqlStatementBuilder,
            UniqueIdentifierGenerator generator,
            ISqlPreparationStage stage,
            ISqlPreparationContext context)
        {
            ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
            ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
            ArgumentUtility.CheckNotNull("generator", generator);
            ArgumentUtility.CheckNotNull("stage", stage);
            ArgumentUtility.CheckNotNull("context", context);

            EnsureNoTopExpression(sqlStatementBuilder, generator, stage, context);
            EnsureNoGroupExpression(sqlStatementBuilder, generator, stage, context);
            EnsureNoDistinctQuery(sqlStatementBuilder, generator, stage, context);
            UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);

            sqlStatementBuilder.Orderings.Clear();

            sqlStatementBuilder.SelectProjection = new AggregationExpression(
                sqlStatementBuilder.DataInfo.DataType,
                sqlStatementBuilder.SelectProjection,
                AggregationModifier);
        }
 public void SetUp ()
 {
   _stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage>();
   _resolverMock = MockRepository.GenerateMock<IMappingResolver>();
   _mappingResolutionContext = new MappingResolutionContext();
   _generator = new UniqueIdentifierGenerator();
   _groupAggregateSimplifier = MockRepository.GenerateStrictMock<IGroupAggregateSimplifier> ();
 }
 public void SetUp ()
 {
   _generator = new UniqueIdentifierGenerator ();
   _stage = new DefaultSqlPreparationStage (
       CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
   _handler = new AverageResultOperatorHandler ();
   _context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
 }
Beispiel #16
0
        public DefaultMappingResolutionStage(IMappingResolver resolver, UniqueIdentifierGenerator uniqueIdentifierGenerator)
        {
            ArgumentUtility.CheckNotNull("resolver", resolver);
            ArgumentUtility.CheckNotNull("uniqueIdentifierGenerator", uniqueIdentifierGenerator);

            _uniqueIdentifierGenerator = uniqueIdentifierGenerator;
            _resolver = resolver;
        }
Beispiel #17
0
 public void SetUp()
 {
     _resolverMock             = MockRepository.GenerateStrictMock <IMappingResolver>();
     _unresolvedJoinInfo       = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
     _generator                = new UniqueIdentifierGenerator();
     _stageMock                = MockRepository.GenerateStrictMock <IMappingResolutionStage> ();
     _mappingResolutionContext = new MappingResolutionContext();
 }
Beispiel #18
0
 public new void EnsureNoSetOperations(
     SqlStatementBuilder sqlStatementBuilder,
     UniqueIdentifierGenerator generator,
     ISqlPreparationStage stage,
     ISqlPreparationContext context)
 {
     base.EnsureNoSetOperations(sqlStatementBuilder, generator, stage, context);
 }
 public DefaultMappingResolutionStage (IMappingResolver resolver, UniqueIdentifierGenerator uniqueIdentifierGenerator)
 {
   ArgumentUtility.CheckNotNull ("resolver", resolver);
   ArgumentUtility.CheckNotNull ("uniqueIdentifierGenerator", uniqueIdentifierGenerator);
   
   _uniqueIdentifierGenerator = uniqueIdentifierGenerator;
   _resolver = resolver;
 }
Beispiel #20
0
 public new void MoveCurrentStatementToSqlTable(
     SqlStatementBuilder sqlStatementBuilder,
     UniqueIdentifierGenerator generator,
     ISqlPreparationContext context,
     Func <ITableInfo, SqlTable> tableGenerator, ISqlPreparationStage stage)
 {
     base.MoveCurrentStatementToSqlTable(sqlStatementBuilder, generator, context, tableGenerator, stage);
 }
 public void SetUp ()
 {
   _resolverMock = MockRepository.GenerateStrictMock<IMappingResolver>();
   _unresolvedJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook();
   _generator = new UniqueIdentifierGenerator();
   _stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage> ();
   _mappingResolutionContext = new MappingResolutionContext();
 }
Beispiel #22
0
 public void SetUp()
 {
     _stageMock                = MockRepository.GenerateStrictMock <IMappingResolutionStage>();
     _resolverMock             = MockRepository.GenerateMock <IMappingResolver>();
     _mappingResolutionContext = new MappingResolutionContext();
     _generator                = new UniqueIdentifierGenerator();
     _groupAggregateSimplifier = MockRepository.GenerateStrictMock <IGroupAggregateSimplifier> ();
 }
Beispiel #23
0
 public void SetUp()
 {
     _generator = new UniqueIdentifierGenerator();
     _stage     = new DefaultSqlPreparationStage(
         CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
     _handler = new AverageResultOperatorHandler();
     _context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
 }
 public void SetUp()
 {
     _stageMock = MockRepository.GenerateStrictMock <ISqlPreparationStage>();
     _generator = new UniqueIdentifierGenerator();
     _context   = SqlStatementModelObjectMother.CreateSqlPreparationContext();
     _methodCallTransformerProvider = CompoundMethodCallTransformerProvider.CreateDefault();
     _visitor = new TestableSqlPreparationFromExpressionVisitor(
         _generator, _stageMock, _methodCallTransformerProvider, _context, info => new SqlTable(info, JoinSemantics.Inner));
 }
Beispiel #25
0
        public IResolvedTableInfo ResolveTableInfo(UnresolvedTableInfo tableInfo, UniqueIdentifierGenerator generator)
        {
            ArgumentUtility.CheckNotNull("tableInfo", tableInfo);
            ArgumentUtility.CheckNotNull("generator", generator);

            var classDefinition = GetClassDefinition(tableInfo.ItemType);

            return(_storageSpecificExpressionResolver.ResolveTable(classDefinition, generator.GetUniqueIdentifier("t")));
        }
 public TestableSqlPreparationFromExpressionVisitor(
     UniqueIdentifierGenerator generator,
     ISqlPreparationStage stage,
     IMethodCallTransformerProvider provider,
     ISqlPreparationContext context,
     Func <ITableInfo, SqlTable> tableGenerator)
     : base(generator, stage, provider, context, tableGenerator)
 {
 }
 public TestableSqlPreparationFromExpressionVisitor (
     UniqueIdentifierGenerator generator,
     ISqlPreparationStage stage,
     IMethodCallTransformerProvider provider,
     ISqlPreparationContext context,
     Func<ITableInfo, SqlTable> tableGenerator)
     : base (generator, stage, provider, context, tableGenerator)
 {
 }
 public void SetUp ()
 {
   _stageMock = MockRepository.GenerateStrictMock<ISqlPreparationStage>();
   _generator = new UniqueIdentifierGenerator();
   _context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
   _methodCallTransformerProvider = CompoundMethodCallTransformerProvider.CreateDefault();
   _visitor = new TestableSqlPreparationFromExpressionVisitor (
       _generator, _stageMock, _methodCallTransformerProvider, _context, info => new SqlTable (info, JoinSemantics.Inner));
 }
 public void SetUp ()
 {
   _stageMock = MockRepository.GenerateMock<IMappingResolutionStage>();
   _resolverMock = MockRepository.GenerateMock<IMappingResolver>();
   _unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook));
   _resolvedTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook));
   _generator = new UniqueIdentifierGenerator();
   _sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook));
   _mappingResolutionContext = new MappingResolutionContext();
 }
 public void SetUp()
 {
     _stageMock                = MockRepository.GenerateMock <IMappingResolutionStage>();
     _resolverMock             = MockRepository.GenerateMock <IMappingResolver>();
     _unresolvedTableInfo      = SqlStatementModelObjectMother.CreateUnresolvedTableInfo(typeof(Cook));
     _resolvedTableInfo        = SqlStatementModelObjectMother.CreateResolvedTableInfo(typeof(Cook));
     _generator                = new UniqueIdentifierGenerator();
     _sqlStatement             = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
     _mappingResolutionContext = new MappingResolutionContext();
 }
 public void ShouldIncrementProperly()
 {
     _systemUnderTest = new UniqueIdentifierGenerator(Sequence.LowerCaseSequence(), "a");
     _systemUnderTest.GetNext().Should().Be("b");
     _systemUnderTest.GetNext().Should().Be("c");
     _systemUnderTest.GetNext().Should().Be("d");
     _systemUnderTest.GetNext().Should().Be("e");
     _systemUnderTest.GetNext().Should().Be("f");
     _systemUnderTest.GetNext().Should().Be("g");
 }
    public static IResolvedTableInfo ResolveTableInfo (ITableInfo tableInfo, IMappingResolver resolver, UniqueIdentifierGenerator generator, IMappingResolutionStage stage, IMappingResolutionContext context)
    {
      ArgumentUtility.CheckNotNull ("tableInfo", tableInfo);
      ArgumentUtility.CheckNotNull ("resolver", resolver);
      ArgumentUtility.CheckNotNull ("stage", stage);
      ArgumentUtility.CheckNotNull ("context", context);

      var visitor = new ResolvingTableInfoVisitor (resolver, generator, stage, context);
      return (IResolvedTableInfo) tableInfo.Accept (visitor);
    }
 public void SetUp ()
 {
   _handler = new TestableResultOperatorHandler();
   _resultOperator = new TestChoiceResultOperator (false);
   _statementBuilder = new SqlStatementBuilder();
   _statementBuilder.SelectProjection = Expression.Constant ("select");
   _statementBuilder.DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook()));
   _generator = new UniqueIdentifierGenerator();
   _stageMock = MockRepository.GenerateMock<ISqlPreparationStage>();
   _context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
 }
 public void SetUp ()
 {
   _stageMock = MockRepository.GenerateMock<ISqlPreparationStage> ();
   _generator = new UniqueIdentifierGenerator ();
   _handler = new CastResultOperatorHandler ();
   _sqlStatementBuilder = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement ())
   {
     DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook ()))
   };
   _context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
 }
 public void SetUp()
 {
     _handler          = new TestableResultOperatorHandler();
     _resultOperator   = new TestChoiceResultOperator(false);
     _statementBuilder = new SqlStatementBuilder();
     _statementBuilder.SelectProjection = Expression.Constant("select");
     _statementBuilder.DataInfo         = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook()));
     _generator = new UniqueIdentifierGenerator();
     _stageMock = MockRepository.GenerateMock <ISqlPreparationStage>();
     _context   = SqlStatementModelObjectMother.CreateSqlPreparationContext();
 }
 public void SetUp ()
 {
   _generator = new UniqueIdentifierGenerator ();
   _stage = new DefaultSqlPreparationStage (new CompoundMethodCallTransformerProvider (), new ResultOperatorHandlerRegistry (), _generator);
   _handler = new SumResultOperatorHandler ();
   _sqlStatementBuilder = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement ())
   {
     DataInfo = new StreamedSequenceInfo (typeof (int[]), Expression.Constant (5))
   };
   _context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
 }
 public void SetUp()
 {
     _generator           = new UniqueIdentifierGenerator();
     _stage               = new DefaultSqlPreparationStage(new CompoundMethodCallTransformerProvider(), new ResultOperatorHandlerRegistry(), _generator);
     _handler             = new SumResultOperatorHandler();
     _sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement())
     {
         DataInfo = new StreamedSequenceInfo(typeof(int[]), Expression.Constant(5))
     };
     _context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
 }
Beispiel #38
0
        public virtual void SetUp()
        {
            _cooks       = ExpressionHelper.CreateQueryable <Cook>();
            _knives      = ExpressionHelper.CreateQueryable <Knife> ();
            _kitchens    = ExpressionHelper.CreateQueryable <Kitchen>();
            _restaurants = ExpressionHelper.CreateQueryable <Restaurant>();
            _chefs       = ExpressionHelper.CreateQueryable <Chef>();
            _companies   = ExpressionHelper.CreateQueryable <Company>();

            _generator = new UniqueIdentifierGenerator();
        }
    public Expression ResolveReference (SqlTableBase sqlTable, IMappingResolver mappingResolver, IMappingResolutionContext context, UniqueIdentifierGenerator generator)
    {
      ArgumentUtility.CheckNotNull ("sqlTable", sqlTable);
      ArgumentUtility.CheckNotNull ("mappingResolver", mappingResolver);
      ArgumentUtility.CheckNotNull ("context", context);
      ArgumentUtility.CheckNotNull ("generator", generator);

      var entity = (SqlEntityExpression) mappingResolver.ResolveSimpleTableInfo (this, generator);
      context.AddSqlEntityMapping (entity, sqlTable);
      return entity;
    }
 public void SetUp()
 {
     _stageMock           = MockRepository.GenerateMock <ISqlPreparationStage> ();
     _generator           = new UniqueIdentifierGenerator();
     _handler             = new CastResultOperatorHandler();
     _sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement())
     {
         DataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook()))
     };
     _context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
 }
    protected ResolvingTableInfoVisitor (IMappingResolver resolver, UniqueIdentifierGenerator generator, IMappingResolutionStage stage, IMappingResolutionContext context)
    {
      ArgumentUtility.CheckNotNull ("generator", generator);
      ArgumentUtility.CheckNotNull ("resolver", resolver);
      ArgumentUtility.CheckNotNull ("stage", stage);
      ArgumentUtility.CheckNotNull ("context", context);

      _resolver = resolver;
      _generator = generator;
      _stage= stage;
      _context = context;
    }
        protected ResolvingTableInfoVisitor(IMappingResolver resolver, UniqueIdentifierGenerator generator, IMappingResolutionStage stage, IMappingResolutionContext context)
        {
            ArgumentUtility.CheckNotNull("generator", generator);
            ArgumentUtility.CheckNotNull("resolver", resolver);
            ArgumentUtility.CheckNotNull("stage", stage);
            ArgumentUtility.CheckNotNull("context", context);

            _resolver  = resolver;
            _generator = generator;
            _stage     = stage;
            _context   = context;
        }
Beispiel #43
0
        protected void EnsureNoDistinctQuery(
            SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
        {
            ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
            ArgumentUtility.CheckNotNull("generator", generator);
            ArgumentUtility.CheckNotNull("stage", stage);

            if (sqlStatementBuilder.IsDistinctQuery)
            {
                MoveCurrentStatementToSqlTable(sqlStatementBuilder, generator, context, info => new SqlTable(info, JoinSemantics.Inner), stage);
            }
        }
Beispiel #44
0
        public SqlPreparationSubStatementTableFactory(
            ISqlPreparationStage stage,
            ISqlPreparationContext context,
            UniqueIdentifierGenerator uniqueIdentifierGenerator)
        {
            ArgumentUtility.CheckNotNull("stage", stage);
            ArgumentUtility.CheckNotNull("context", context);

            _stage = stage;
            _uniqueIdentifierGenerator = uniqueIdentifierGenerator;
            _context = context;
        }
        public void ShouldWorkWithCustomSequence()
        {
            var sequence = new Sequence(new [] { 'a', 'b' });

            _systemUnderTest = new UniqueIdentifierGenerator(sequence, "a");
            _systemUnderTest.GetNext().Should().Be("b");
            _systemUnderTest.GetNext().Should().Be("aa");
            _systemUnderTest.GetNext().Should().Be("ab");
            _systemUnderTest.GetNext().Should().Be("ba");
            _systemUnderTest.GetNext().Should().Be("bb");
            _systemUnderTest.GetNext().Should().Be("aaa");
        }
    public SqlPreparationSubStatementTableFactory (
        ISqlPreparationStage stage, 
        ISqlPreparationContext context, 
        UniqueIdentifierGenerator uniqueIdentifierGenerator)
    {
      ArgumentUtility.CheckNotNull ("stage", stage);
      ArgumentUtility.CheckNotNull ("context", context);

      _stage = stage;
      _uniqueIdentifierGenerator = uniqueIdentifierGenerator;
      _context = context;
    }
 protected SqlPreparationFromExpressionVisitor (
     UniqueIdentifierGenerator generator,
     ISqlPreparationStage stage,
     IMethodCallTransformerProvider provider,
     ISqlPreparationContext context,
     Func<ITableInfo, SqlTable> tableGenerator)
     : base (context, stage, provider)
 {
   _generator = generator;
   FromExpressionInfo = null;
   _tableGenerator = tableGenerator;
 }
        public IResolvedTableInfo ResolveTableInfo(UnresolvedTableInfo tableInfo, UniqueIdentifierGenerator generator)
        {
            ArgumentUtility.CheckNotNull("tableInfo", tableInfo);
            ArgumentUtility.CheckNotNull("generator", generator);

            MetaTable table = GetMetaTable(tableInfo.ItemType);

            // TODO RM-3127: Refactor when re-linq supports schema names
            var tableName = table.TableName.StartsWith("dbo.") ? table.TableName.Substring(4) : table.TableName;

            return(new ResolvedSimpleTableInfo(tableInfo.ItemType, tableName, generator.GetUniqueIdentifier("t")));
        }
    public DefaultSqlPreparationStage (
        IMethodCallTransformerProvider methodCallTransformerProvider,
        ResultOperatorHandlerRegistry resultOperatorHandlerRegistry,
        UniqueIdentifierGenerator uniqueIdentifierGenerator)
    {
      ArgumentUtility.CheckNotNull ("methodCallTransformerProvider", methodCallTransformerProvider);
      ArgumentUtility.CheckNotNull ("resultOperatorHandlerRegistry", resultOperatorHandlerRegistry);
      ArgumentUtility.CheckNotNull ("uniqueIdentifierGenerator", uniqueIdentifierGenerator);

      _methodCallTransformerProvider = methodCallTransformerProvider;
      _resultOperatorHandlerRegistry = resultOperatorHandlerRegistry;
      _uniqueIdentifierGenerator = uniqueIdentifierGenerator;
    }
    public void SetUp ()
    {
      _resolverMock = MockRepository.GenerateMock<IMappingResolver>();
      _uniqueIdentifierGenerator = new UniqueIdentifierGenerator();

      _unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook));
      _sqlTable = SqlStatementModelObjectMother.CreateSqlTable (_unresolvedTableInfo);
      _fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook));

      _stage = new DefaultMappingResolutionStage (_resolverMock, _uniqueIdentifierGenerator);

      _mappingResolutionContext = new MappingResolutionContext();
    }
    public void SetUp ()
    {
      _stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage>();
      _resolverMock = MockRepository.GenerateStrictMock<IMappingResolver>();
      _sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo (typeof (Cook));
      _mappingResolutionContext = new MappingResolutionContext();
      _generator = new UniqueIdentifierGenerator();
      _entityIdentityResolverMock = MockRepository.GenerateStrictMock<IEntityIdentityResolver> ();
      _compoundComparisonSplitterMock = MockRepository.GenerateStrictMock<ICompoundExpressionComparisonSplitter> ();
      _namedExpressionCombinerMock = MockRepository.GenerateStrictMock<INamedExpressionCombiner>();
      _groupAggregateSimplifierMock = MockRepository.GenerateStrictMock<IGroupAggregateSimplifier>();

      _visitor = CreateVisitor (true);
    }
    public static ResolvedJoinInfo ResolveJoinInfo (
        IJoinInfo joinInfo,
        IMappingResolver resolver,
        UniqueIdentifierGenerator generator,
        IMappingResolutionStage stage,
        IMappingResolutionContext context)
    {
      ArgumentUtility.CheckNotNull ("joinInfo", joinInfo);
      ArgumentUtility.CheckNotNull ("resolver", resolver);
      ArgumentUtility.CheckNotNull ("generator", generator);
      ArgumentUtility.CheckNotNull ("stage", stage);
      ArgumentUtility.CheckNotNull ("context", context);

      var visitor = new ResolvingJoinInfoVisitor (resolver, generator, stage, context);
      return (ResolvedJoinInfo) joinInfo.Accept (visitor);
    }
    public void SetUp ()
    {
      _stageMock = MockRepository.GenerateStrictMock<ISqlPreparationStage>();
      _context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
      _generator = new UniqueIdentifierGenerator();
      _factory = new SqlPreparationSubStatementTableFactory (_stageMock, _context, _generator);

      var builderForStatementWithOrderings = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatementWithCook ())
      {
        Orderings = {
            new Ordering (Expression.Constant ("order1"), OrderingDirection.Desc),
            new Ordering (Expression.Constant ("order2"), OrderingDirection.Asc),
        }
      };
      _statementWithOrderings = builderForStatementWithOrderings.GetSqlStatement ();
    }
    public void SetUp ()
    {
      _generator = new UniqueIdentifierGenerator();
      _context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
      _defaultStage = new DefaultSqlPreparationStage (
          CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);

      _mainFromClause = ExpressionHelper.CreateMainFromClause<Cook>();
      _selectClause = ExpressionHelper.CreateSelectClause (_mainFromClause);
      _orderByClause = ExpressionHelper.CreateOrderByClause();
      _queryModel = new QueryModel (_mainFromClause, _selectClause);

      _stageMock = MockRepository.GenerateStrictMock<ISqlPreparationStage>();
      _visitor = new TestableSqlPreparationQueryModelVisitor (_context, _stageMock);
      _visitorPartialMock = MockRepository.GeneratePartialMock<TestableSqlPreparationQueryModelVisitor> (_context, _stageMock);
    }
    public virtual IResolvedTableInfo ResolveTableInfo (UnresolvedTableInfo tableInfo, UniqueIdentifierGenerator generator)
    {
      switch (tableInfo.ItemType.Name)
      {
        case "Cook":
        case "Knife":
        case "Kitchen":
        case "Restaurant":
        case "Company":
          return CreateResolvedTableInfo (tableInfo.ItemType, generator);
        case "Chef":
          return new ResolvedSimpleTableInfo (tableInfo.ItemType, "dbo."+tableInfo.ItemType.Name + "Table", generator.GetUniqueIdentifier ("t"));
      }

      throw new UnmappedItemException ("The type " + tableInfo.ItemType + " cannot be queried from the stub provider.");
    }
    public static SqlStatement TransformQueryModel (
        QueryModel queryModel,
        ISqlPreparationContext parentPreparationContext,
        ISqlPreparationStage stage,
        UniqueIdentifierGenerator generator,
        ResultOperatorHandlerRegistry resultOperatorHandlerRegistry)
    {
      ArgumentUtility.CheckNotNull ("queryModel", queryModel);
      ArgumentUtility.CheckNotNull ("stage", stage);
      ArgumentUtility.CheckNotNull ("generator", generator);
      ArgumentUtility.CheckNotNull ("resultOperatorHandlerRegistry", resultOperatorHandlerRegistry);

      var visitor = new SqlPreparationQueryModelVisitor (parentPreparationContext, stage, generator, resultOperatorHandlerRegistry);
      queryModel.Accept (visitor);

      return visitor.GetSqlStatement();
    }
    protected SqlPreparationQueryModelVisitor (
        ISqlPreparationContext parentContext,
        ISqlPreparationStage stage,
        UniqueIdentifierGenerator generator,
        ResultOperatorHandlerRegistry resultOperatorHandlerRegistry)
    {
      ArgumentUtility.CheckNotNull ("stage", stage);
      ArgumentUtility.CheckNotNull ("generator", generator);
      ArgumentUtility.CheckNotNull ("resultOperatorHandlerRegistry", resultOperatorHandlerRegistry);

      _stage = stage;
      _generator = generator;
      _resultOperatorHandlerRegistry = resultOperatorHandlerRegistry;

      _sqlStatementBuilder = new SqlStatementBuilder();
      _context = new SqlPreparationContext (parentContext, _sqlStatementBuilder);
    }
    public void ResolveReference ()
    {
      var sqlTable = new SqlTable (_tableInfo, JoinSemantics.Inner);
      
      var generator = new UniqueIdentifierGenerator ();
      var resolverMock = MockRepository.GenerateStrictMock<IMappingResolver> ();
      var mappingResolutionContext = new MappingResolutionContext ();

      resolverMock.Replay ();

      var result = _tableInfo.ResolveReference (sqlTable, resolverMock, mappingResolutionContext, generator);

      Assert.That (result, Is.TypeOf (typeof (SqlColumnDefinitionExpression)));
      Assert.That (((SqlColumnDefinitionExpression) result).ColumnName, Is.EqualTo ("test"));
      Assert.That (((SqlColumnDefinitionExpression) result).OwningTableAlias, Is.EqualTo (_tableInfo.TableAlias));
      Assert.That (result.Type, Is.EqualTo (typeof (int)));
    }
    public void ResolveReference ()
    {
      var sqlTable = new SqlTable (_tableInfo, JoinSemantics.Inner);
      var fakeResult = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));

      var generator = new UniqueIdentifierGenerator();
      var resolverMock = MockRepository.GenerateStrictMock<IMappingResolver>();
      var mappingResolutionContext = new MappingResolutionContext();

      resolverMock
          .Expect (mock => mock.ResolveSimpleTableInfo (_tableInfo, generator))
          .Return (fakeResult);
      resolverMock.Replay ();

      var result = _tableInfo.ResolveReference (sqlTable, resolverMock, mappingResolutionContext, generator);

      resolverMock.VerifyAllExpectations ();
      Assert.That (result, Is.SameAs (fakeResult));
      Assert.That (mappingResolutionContext.GetSqlTableForEntityExpression ((SqlEntityExpression) result), Is.SameAs (sqlTable));
    }
    public void SetUp ()
    {
      _stageMock = MockRepository.GenerateMock<ISqlPreparationStage> ();
      _generator = new UniqueIdentifierGenerator ();
      _context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();

      _handler = new SkipResultOperatorHandler ();
      
      _sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Inner);
      _selectProjection = new SqlTableReferenceExpression (_sqlTable);

      _ordering = new Ordering (Expression.Constant (7), OrderingDirection.Asc);
      _sqlStatementBuilder = new SqlStatementBuilder
      {
        SelectProjection = _selectProjection,
        DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook ())),
        SqlTables = { _sqlTable },
      };

      _tupleCtor = _tupleCtor = typeof (KeyValuePair<Cook, int>).GetConstructor (new[] { typeof (Cook), typeof (int) });
    }