コード例 #1
0
        public static Type DetermineType(SqlScalarExpression expression, RawData rawData)
        {
            if (expression is SqlUnaryScalarExpression unaryScalarExpression)
            {
                expression = unaryScalarExpression.Expression;
            }
            switch (expression)
            {
            case SqlColumnRefExpression columnRef:
            {
                var field = Helper.GetTableColumn(columnRef, rawData);
                return(field.Column.NetDataType);
            }

            case SqlScalarVariableRefExpression variableRef:
            {
                var parameter = GetParameter(variableRef.VariableName, rawData.Command.Parameters, rawData.Command.Variables);
                return(parameter.NetDataType);
            }

            case SqlScalarRefExpression scalarRef:
            {
                var field = Helper.GetTableColumn((SqlObjectIdentifier)scalarRef.MultipartIdentifier, rawData);
                return(field.Column.NetDataType);
            }

            case SqlAggregateFunctionCallExpression functionCall:
            {
                var selectFunction = new SelectDataBuilder(  ).Build(functionCall, rawData);
                return(selectFunction.ReturnType);
            }

            case SqlSearchedCaseExpression caseExpression:
            {
                var selectFunction = new SelectDataFromCaseExpression(caseExpression, rawData);
                return(selectFunction.ReturnType);
            }

            case SqlLiteralExpression literalExpression:
            {
                return(GetTypeFromLiteralType(literalExpression.Type));
            }

            case SqlBinaryScalarExpression binaryScalarExpression:
            {
                var selectFunction = new SelectDataFromBinaryScalarExpression(binaryScalarExpression, rawData);
                return(selectFunction.ReturnType);
            }
            }

            return(null);
        }
コード例 #2
0
        public static FullTypeInfo DetermineFullTypeInfo(SqlScalarExpression expression, RawData rawData)
        {
            switch (expression)
            {
            case SqlColumnRefExpression columnRef:
            {
                var field = Helper.GetTableColumn(columnRef, rawData);
                return(new FullTypeInfo {
                        DbDataType = field.Column.DbDataType, NetDataType = field.Column.NetDataType
                    });
            }

            case SqlScalarVariableRefExpression variableRef:
            {
//                    Helper.GetValueFromParameter( variableRef.VariableName, rawData.Parameters );
                return(null);
            }

            case SqlScalarRefExpression scalarRef:
            {
                var field = Helper.GetTableColumn((SqlObjectIdentifier)scalarRef.MultipartIdentifier, rawData);
                return(new FullTypeInfo {
                        DbDataType = field.Column.DbDataType, NetDataType = field.Column.NetDataType
                    });
            }

            case SqlAggregateFunctionCallExpression functionCall:
            {
                var selectFunction = new SelectDataBuilder(  ).Build(functionCall, rawData);
                return(new FullTypeInfo {
                        DbDataType = selectFunction.DbType, NetDataType = selectFunction.ReturnType
                    });
            }

            case SqlSearchedCaseExpression caseExpression:
            {
                var selectFunction = new SelectDataFromCaseExpression(caseExpression, rawData);
                return(new FullTypeInfo {
                        DbDataType = selectFunction.DbType, NetDataType = selectFunction.ReturnType
                    });
            }

            case SqlLiteralExpression literalExpression:
            {
                return(new FullTypeInfo {
                        DbDataType = GetDbTypeFromLiteralType(literalExpression.Type), NetDataType = GetTypeFromLiteralType(literalExpression.Type)
                    });
            }
            }

            return(null);
        }
コード例 #3
0
        private void AddFieldFromCaseExpression(SqlSearchedCaseExpression caseExpression, string name, MemoryDbDataReader.ResultBatch batch, RawData rawData)
        {
            var select = new SelectDataFromCaseExpression(caseExpression, rawData);

            AddFieldFromSelectData(name, batch, select);
        }
コード例 #4
0
        public static object GetValue(SqlScalarExpression expression, Type type, RawData rawData, List <RawTableRow> row, bool getTypeFromLiteral = false)
        {
            switch (expression)
            {
            case SqlColumnRefExpression columnRef:
            {
                var field  = GetTableColumn(columnRef, rawData);
                var select = new SelectDataFromColumn(field, rawData);
                return(GetReturnValue(select, row));
            }

            case SqlUnaryScalarExpression unaryScalarExpression:
            {
                var value = GetValue(unaryScalarExpression.Expression, type, rawData, row);
                if (unaryScalarExpression.Operator == SqlUnaryScalarOperatorType.Negative)
                {
                    value = HelperReflection.Negate(value);
                }
                return(value);
            }

            case SqlLiteralExpression literal:
            {
                if (literal.Type == LiteralValueType.Null)
                {
                    return(null);
                }

                var literalType = getTypeFromLiteral ? GetTypeFromLiteralType(literal.Type) : type;
                return(GetValueFromString(literalType, literal));
            }

            case SqlScalarVariableRefExpression variableRef:
            {
                return(GetValueFromParameter(variableRef.VariableName, rawData.Parameters, rawData.Command.Variables));
            }

            case SqlScalarRefExpression scalarRef:
            {
                var field  = GetTableColumn((SqlObjectIdentifier)scalarRef.MultipartIdentifier, rawData);
                var select = new SelectDataFromColumn(field, rawData);
                return(GetReturnValue(select, row));
            }

            case SqlGlobalScalarVariableRefExpression globalRef:
            {
                var select = new SelectDataFromGlobalVariables(globalRef.VariableName, rawData);
                return(GetReturnValue(select, row));
            }

            case SqlBuiltinScalarFunctionCallExpression functionCall:
            {
                var select = new SelectDataBuilder(  ).Build(functionCall, rawData);
                return(GetReturnValue(select, row));
            }

            case SqlSearchedCaseExpression caseExpression:
            {
                var select = new SelectDataFromCaseExpression(caseExpression, rawData);
                return(GetReturnValue(select, row));
            }

            case SqlScalarSubQueryExpression subQuery:
            {
                var database = new MemoryDbConnection().GetMemoryDatabase( );
                var command  = new MemoryDbCommand(rawData.Command.Connection, rawData.Command.Parameters, rawData.Command.Variables);
                return(database.ExecuteSqlScalar(subQuery.QueryExpression.Sql, command));
            }

            case SqlBinaryScalarExpression binaryScalarExpression:
            {
                var select = new SelectDataFromBinaryScalarExpression(binaryScalarExpression, rawData);
                return(GetReturnValue(select, row));
            }

            default:
                throw new NotImplementedException($"Unsupported scalarExpression : '{ expression.GetType(  ) }'");
            }
        }