public bool Read()
 {
     var haveRow = _reader.Read();
     if (haveRow)
     {
         var values = new object[_reader.FieldCount];
         _reader.GetValues(values);
         _currentRow = _rowViewFactoryMethod(values);
     }
     else
     {
         _currentRow = null;
     }
     return haveRow;
 }
        // internal for testing
        internal FunctionParameter CreateReturnParameter(
            FunctionDetailsRowView functionDetailsRow, Dictionary<string, RowType> tvfReturnTypes, List<EdmSchemaError> errors)
        {
            Debug.Assert(functionDetailsRow != null, "functionDetailsRow != null");
            Debug.Assert(tvfReturnTypes != null, "tvfReturnTypes != null");
            Debug.Assert(errors != null, "errors != null");

            EdmType returnType = null;

            if (functionDetailsRow.ReturnType != null)
            {
                bool excludedForVersion;
                returnType = GetStorePrimitiveTypeForVersion(functionDetailsRow.ReturnType, out excludedForVersion);

                if (returnType == null)
                {
                    errors.Add(
                        new EdmSchemaError(
                            string.Format(
                                CultureInfo.InvariantCulture,
                                excludedForVersion
                                    ? Resources_VersioningFacade.UnsupportedFunctionReturnDataTypeForTarget
                                    : Resources_VersioningFacade.UnsupportedFunctionReturnDataType,
                                functionDetailsRow.ProcedureName,
                                functionDetailsRow.ReturnType),
                            (int)ModelBuilderErrorCode.UnsupportedType,
                            EdmSchemaErrorSeverity.Warning));
                }
            }
            else if (functionDetailsRow.IsTvf)
            {
                RowType rowType;
                if (tvfReturnTypes.TryGetValue(functionDetailsRow.GetMostQualifiedFunctionName(), out rowType)
                    && !MetadataItemHelper.HasSchemaErrors(rowType))
                {
                    returnType = rowType.GetCollectionType();
                }
                else
                {
                    errors.Add(
                        new EdmSchemaError(
                            string.Format(
                                CultureInfo.InvariantCulture,
                                Resources_VersioningFacade.TableReferencedByTvfWasNotFound,
                                functionDetailsRow.GetMostQualifiedFunctionName()),
                            (int)ModelBuilderErrorCode.MissingTvfReturnTable,
                            EdmSchemaErrorSeverity.Warning));

                    // invalid row types will not be serialized so 
                    // reassign errors to the parent TVF definition 
                    if (rowType != null)
                    {
                        errors.AddRange(MetadataItemHelper.GetSchemaErrors(rowType));
                    }
                }
            }

            return
                returnType != null
                    ? FunctionParameter.Create("ReturnType", returnType, ParameterMode.ReturnValue)
                    : null;
        }
        // internal for testing
        internal PrimitiveType GetFunctionParameterType(
            FunctionDetailsRowView functionDetailsRow, int parameterIndex, IList<EdmSchemaError> errors)
        {
            Debug.Assert(functionDetailsRow != null, "functionDetailsRow != null");
            Debug.Assert(errors != null, "errors != null");

            var parameterTypeName = functionDetailsRow.IsParameterTypeNull ? null : functionDetailsRow.ParameterType;

            bool excludedForVersion;
            var parameterType = GetStorePrimitiveTypeForVersion(parameterTypeName, out excludedForVersion);

            if (parameterType == null)
            {
                errors.Add(
                    new EdmSchemaError(
                        string.Format(
                            CultureInfo.InvariantCulture,
                            excludedForVersion
                                ? Resources_VersioningFacade.UnsupportedFunctionParameterDataTypeForTarget
                                : Resources_VersioningFacade.UnsupportedFunctionParameterDataType,
                            functionDetailsRow.ProcedureName,
                            functionDetailsRow.ParameterName,
                            parameterIndex,
                            parameterTypeName ?? "null"),
                        (int)ModelBuilderErrorCode.UnsupportedType,
                        EdmSchemaErrorSeverity.Warning));
            }

            return parameterType;
        }
        // internal for testing
        internal FunctionParameter CreateFunctionParameter(
            FunctionDetailsRowView functionDetailsRow, UniqueIdentifierService uniqueIdentifierService, int parameterIndex,
            IList<EdmSchemaError> errors)
        {
            Debug.Assert(functionDetailsRow != null, "functionDetailsRow != null");
            Debug.Assert(uniqueIdentifierService != null, "uniqueIdentifierService != null");
            Debug.Assert(errors != null, "errors != null");

            var parameterType = GetFunctionParameterType(functionDetailsRow, parameterIndex, errors);
            if (parameterType == null)
            {
                return null;
            }

            ParameterMode parameterMode;
            if (!functionDetailsRow.TryGetParameterMode(out parameterMode))
            {
                errors.Add(
                    new EdmSchemaError(
                        string.Format(
                            CultureInfo.InvariantCulture,
                            Resources_VersioningFacade.ParameterDirectionNotValid,
                            functionDetailsRow.ProcedureName,
                            functionDetailsRow.ParameterName,
                            functionDetailsRow.ProcParameterMode),
                        (int)ModelBuilderErrorCode.ParameterDirectionNotValid,
                        EdmSchemaErrorSeverity.Warning));
                return null;
            }

            var parameterName =
                uniqueIdentifierService.AdjustIdentifier(
                    ModelGeneratorUtils.CreateValidEcmaName(functionDetailsRow.ParameterName, 'p'));

            return FunctionParameter.Create(parameterName, parameterType, parameterMode);
        }