コード例 #1
0
        private ConstructedValueExpression CompileArrayOfScalar(MapTypeContext context, ConstructorInfo constructor, List <ColumnInfo> columns, Type elementType)
        {
            var arrayVar    = context.CreateVariable(context.TargetType, "array");
            var expressions = new List <Expression>();
            var variables   = new List <ParameterExpression>();

            variables.Add(arrayVar);
            expressions.Add(
                Expression.Assign(
                    arrayVar,
                    Expression.New(
                        constructor,
                        Expression.Constant(columns.Count)
                        )
                    )
                );
            for (int i = 0; i < columns.Count; i++)
            {
                var columnState         = context.GetSubstateForColumn(columns[i], elementType, null);
                var getScalarExpression = _scalars.Compile(columnState);
                expressions.AddRange(getScalarExpression.Expressions);
                expressions.Add(
                    Expression.Assign(
                        Expression.ArrayAccess(
                            arrayVar,
                            Expression.Constant(i)
                            ),
                        getScalarExpression.FinalValue
                        )
                    );
                variables.AddRange(getScalarExpression.Variables);
            }

            return(new ConstructedValueExpression(expressions, arrayVar, variables));
        }
コード例 #2
0
        public static ConstructedValueExpression GetCollectionPopulateStatements(ICompiler scalars, ICompiler nonScalars, MapTypeContext context, Type elementType, Expression listVar, MethodInfo addMethod)
        {
            if (!context.HasColumns())
            {
                return(new ConstructedValueExpression(null));
            }

            var expressions = new List <Expression>();
            var variables   = new List <ParameterExpression>();

            // For scalar types (object is treated like a scalar here), map each column to an entry in the
            // array, consuming all remaining columns.
            if (elementType.IsSupportedPrimitiveType() || elementType == typeof(object))
            {
                var columns = context.GetColumns();
                foreach (var column in columns)
                {
                    var columnState = context.GetSubstateForColumn(column, elementType, null);
                    var result      = scalars.Compile(columnState);
                    expressions.AddRange(result.Expressions);
                    expressions.Add(
                        Expression.Call(
                            listVar,
                            addMethod,
                            result.FinalValue
                            )
                        );
                    variables.AddRange(result.Variables);
                }

                return(new ConstructedValueExpression(expressions, null, variables));
            }

            // For all non-scalar types
            // loop so long as we have columns and consume columns every iteration.
            var elementState    = context.ChangeTargetType(elementType);
            var numberOfColumns = context.NumberOfColumns();

            while (numberOfColumns > 0)
            {
                var result             = nonScalars.Compile(elementState);
                var newNumberOfColumns = context.NumberOfColumns();

                // We haven't consumed any new columns, so we're done.
                if (newNumberOfColumns == numberOfColumns)
                {
                    break;
                }
                expressions.AddRange(result.Expressions);
                expressions.Add(
                    Expression.Call(listVar, addMethod, result.FinalValue)
                    );
                variables.AddRange(result.Variables);
                numberOfColumns = newNumberOfColumns;
            }
            return(new ConstructedValueExpression(expressions, null, variables));
        }
コード例 #3
0
        public static ConstructedValueExpression AddDictionaryPopulateStatements(ICompiler values, MapTypeContext context, Type elementType, Expression dictVar, MethodInfo addMethod)
        {
            var expressions = new List <Expression>();
            var variables   = new List <ParameterExpression>();

            if (context.Name == null)
            {
                var firstColumnsByName = context.GetFirstIndexForEachColumnName();
                foreach (var column in firstColumnsByName)
                {
                    var substate            = context.GetSubstateForProperty(column.CanonicalName, null, elementType);
                    var getScalarExpression = values.Compile(substate);
                    expressions.AddRange(getScalarExpression.Expressions);
                    expressions.Add(
                        Expression.Call(
                            dictVar,
                            addMethod,
                            Expression.Constant(column.OriginalName),
                            getScalarExpression.FinalValue
                            )
                        );
                    variables.AddRange(getScalarExpression.Variables);
                }

                return(new ConstructedValueExpression(expressions, null, variables));
            }

            var columns = context.GetFirstIndexForEachColumnName();

            foreach (var column in columns)
            {
                var keyName             = column.OriginalName.Substring(context.CurrentPrefix.Length);
                var childName           = column.CanonicalName.Substring(context.CurrentPrefix.Length);
                var columnSubstate      = context.GetSubstateForColumn(column, elementType, childName);
                var getScalarExpression = values.Compile(columnSubstate);
                expressions.AddRange(getScalarExpression.Expressions);
                expressions.Add(
                    Expression.Call(
                        dictVar,
                        addMethod,
                        Expression.Constant(keyName),
                        getScalarExpression.FinalValue
                        )
                    );
                variables.AddRange(getScalarExpression.Variables);
            }

            return(new ConstructedValueExpression(expressions, null, variables));
        }
コード例 #4
0
        public ConstructedValueExpression Compile(MapTypeContext context)
        {
            if (context.TargetType != typeof(object))
            {
                return(ConstructedValueExpression.Nothing);
            }

            // At the top-level (name==null) we convert to dictionary to preserve column name information
            if (context.Name == null)
            {
                // Dictionary mapping logic will group by key name and recurse. When we get back to the
                // ObjectCompiler, we will have a smaller set of columns and we will have a non-null name
                var dictState = context.ChangeTargetType(typeof(Dictionary <string, object>));
                var dictExpr  = _dictionaries.Compile(dictState);
                return(new ConstructedValueExpression(dictExpr.Expressions, Expression.Convert(dictExpr.FinalValue, typeof(object)), dictExpr.Variables));
            }

            var columns    = context.GetColumns().ToList();
            var numColumns = columns.Count;

            // If we have no columns, just return null
            if (numColumns == 0)
            {
                return(new ConstructedValueExpression(
                           Expression.Convert(
                               Expression.Constant(null),
                               typeof(object)
                               )
                           ));
            }

            // If we have exactly one column, map the value as a scalar and return a single result
            if (numColumns == 1)
            {
                var firstColumn = columns[0];
                var objectState = context.GetSubstateForColumn(firstColumn, typeof(object), null);
                var asScalar    = _scalars.Compile(objectState);
                return(new ConstructedValueExpression(asScalar.Expressions, Expression.Convert(asScalar.FinalValue, typeof(object)), asScalar.Variables));
            }

            // If we have more than one column, map to object[]
            var arrayState = context.ChangeTargetType(typeof(object[]));
            var exprs      = _arrays.Compile(arrayState);

            return(new ConstructedValueExpression(exprs.Expressions, Expression.Convert(exprs.FinalValue, typeof(object)), exprs.Variables));
        }