Example #1
0
        static LegacyDbProviderManifestWrapperTests()
        {
            LegacyProviderManifest =
                ((Legacy.DbProviderServices)
                     ((IServiceProvider)Legacy.DbProviderFactories.GetFactory("System.Data.SqlClient"))
                 .GetService(typeof(Legacy.DbProviderServices)))
                .GetProviderManifest("2008");

            ProviderManifestWrapper = new LegacyDbProviderManifestWrapper(LegacyProviderManifest);

            const string emptyCsdl =
                @"<Schema xmlns=""http://schemas.microsoft.com/ado/2009/11/edm"" Namespace=""dummy"" />";

            using (var reader = XmlReader.Create(new StringReader(emptyCsdl)))
            {
                EdmPrimitiveTypes =
                    new EdmItemCollection(new[] { reader }).GetItems <PrimitiveType>().ToDictionary(t => t.Name, t => t);
            }

            using (var reader = XmlReader.Create(new StringReader(emptyCsdl)))
            {
                LegacyEdmPrimitiveTypes =
                    new LegacyMetadata.EdmItemCollection(new[] { reader })
                    .GetItems <LegacyMetadata.PrimitiveType>()
                    .ToDictionary(t => t.Name, t => t);
            }
        }
        protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, System.Data.Common.CommandTrees.DbCommandTree commandTree)
        {
            if (providerManifest == null)
                throw new ArgumentNullException("providerManifest");

            if (commandTree == null)
                throw new ArgumentNullException("commandTree");

            NuoDbCommand command = new NuoDbCommand(PrepareTypeCoercions(commandTree));

            List<DbParameter> parameters;
            CommandType commandType;
            command.CommandText = SqlGenerator.GenerateSql(commandTree, out parameters, out commandType);
            command.CommandType = commandType;

            // Get the function (if any) implemented by the command tree since this influences our interpretation of parameters
            EdmFunction function = null;
            if (commandTree is DbFunctionCommandTree)
            {
                function = ((DbFunctionCommandTree)commandTree).EdmFunction;
            }

            foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters)
            {
                NuoDbParameter parameter;

                // Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and
                // type trump user-defined facets and type in the EntityCommand).
                FunctionParameter functionParameter;
                if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter))
                {
                    parameter = CreateSqlParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value);
                }
                else
                {
                    parameter = CreateSqlParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value);
                }

                command.Parameters.Add(parameter);
            }

            // Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which
            // does not support user parameters, where there is no risk of name collision)
            if (null != parameters && 0 < parameters.Count)
            {
                if (!(commandTree is DbInsertCommandTree) &&
                  !(commandTree is DbUpdateCommandTree) &&
                  !(commandTree is DbDeleteCommandTree))
                {
                    throw new InvalidOperationException("SqlGenParametersNotPermitted");
                }

                foreach (DbParameter parameter in parameters)
                {
                    command.Parameters.Add(parameter);
                }
            }

            return CreateCommandDefinition(command);
        }
        static LegacyDbProviderManifestWrapperTests()
        {
            LegacyProviderManifest =
                ((Legacy.DbProviderServices)
                 ((IServiceProvider)Legacy.DbProviderFactories.GetFactory("System.Data.SqlClient"))
                     .GetService(typeof(Legacy.DbProviderServices)))
                    .GetProviderManifest("2008");

            ProviderManifestWrapper = new LegacyDbProviderManifestWrapper(LegacyProviderManifest);

            const string emptyCsdl =
                @"<Schema xmlns=""http://schemas.microsoft.com/ado/2009/11/edm"" Namespace=""dummy"" />";

            using (var reader = XmlReader.Create(new StringReader(emptyCsdl)))
            {
                EdmPrimitiveTypes =
                    new EdmItemCollection(new[] { reader }).GetItems<PrimitiveType>().ToDictionary(t => t.Name, t => t);
            }

            using (var reader = XmlReader.Create(new StringReader(emptyCsdl)))
            {
                LegacyEdmPrimitiveTypes =
                    new LegacyMetadata.EdmItemCollection(new[] { reader })
                        .GetItems<LegacyMetadata.PrimitiveType>()
                        .ToDictionary(t => t.Name, t => t);
            }
        }
 /// <summary>
 /// create the database command definition.
 /// </summary>
 /// <param name="providerManifest">The provider manifest.</param>
 /// <param name="commandTree">The command tree.</param>
 /// <returns>the command definition.</returns>
 protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, System.Data.Common.CommandTrees.DbCommandTree commandTree)
 {
     var cmdDef = _wrapped.CreateCommandDefinition(providerManifest, commandTree);
     var cmd = cmdDef.CreateCommand();
     Debug.Assert(cmd != null, "cmd != null");
     return CreateCommandDefinition(new ProfiledDbCommand(cmd, cmd.Connection, _profiler));
 }
        /// <summary>
        /// Create a Command Definition object, given the connection and command tree
        /// </summary>
        /// <param name="connection">connection to the underlying provider</param>
        /// <param name="commandTree">command tree for the statement</param>
        /// <returns>an exectable command definition object</returns>
        /// <exception cref="ArgumentNullException">connection and commandTree arguments must not be null</exception>
        protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) {
            EntityUtil.CheckArgumentNull(providerManifest, "providerManifest");
            EntityUtil.CheckArgumentNull(commandTree, "commandTree");

            StoreItemCollection storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace);
            return this.CreateCommandDefinition(storeMetadata.StoreProviderFactory, commandTree);
        }
		/// <summary>
		/// Creates the provider manifest wrapper.
		/// </summary>
		/// <param name="providerInvariantName">Provider invariant name.</param>
		/// <param name="providerManifest">The provider manifest to be wrapped.</param>
		/// <returns><see cref="DbProviderManifest"/> wrapper for given provider invariant name wrapping given provider manifest.</returns>
		public virtual DbProviderManifest CreateProviderManifest(string providerInvariantName, DbProviderManifest providerManifest)
		{
			return new DbProviderManifestWrapper(
				ProviderInvariantName,
				providerInvariantName,
				providerManifest);
		}
 /// <summary>
 /// Create a Command Definition object, given the connection and command tree
 /// </summary>
 /// <param name="providerManifest">provider manifest that was determined from metadata</param>
 /// <param name="commandTree">command tree for the statement</param>
 /// <returns>an exectable command definition object</returns>
 protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) {
     Debug.Assert(providerManifest != null, "CreateCommandDefinition passed null provider manifest to CreateDbCommandDefinition?");
     Debug.Assert(commandTree != null, "CreateCommandDefinition did not validate commandTree argument?");
                 
     DbCommand prototype = CreateCommand(providerManifest, commandTree);
     DbCommandDefinition result = this.CreateCommandDefinition(prototype);
     return result;
 }
 /// <summary>
 /// The constructor for PrimitiveType, it takes in a CLR type containing the identity information
 /// </summary>
 /// <param name="clrType">The CLR type object for this primitive type</param>
 /// <param name="baseType">The base type for this primitive type</param>
 /// <param name="providerManifest">The ProviderManifest of the provider of this type</param>
 internal PrimitiveType(Type clrType,
                        PrimitiveType baseType,
                        DbProviderManifest providerManifest)
     : this(EntityUtil.GenericCheckArgumentNull(clrType, "clrType").Name, clrType.Namespace,
     DataSpace.OSpace, baseType, providerManifest)
 {
     Debug.Assert(clrType == ClrEquivalentType, "not equivalent to ClrEquivalentType");
 }
        /// <summary>
        /// Creates the command definition wrapper for a given provider manifest and command tree.
        /// </summary>
        /// <param name="providerManifest">The provider manifest.</param>
        /// <param name="commandTree">The command tree.</param>
        /// <returns><see cref="DbCommandDefinition"/> object.</returns>
        protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
        {
            var wrapperManifest = (DbProviderManifestWrapper)providerManifest;
            var createDbCommandDefinitionFunction = this.GetCreateDbCommandDefinitionFunction(wrapperManifest.WrappedProviderManifestInvariantName);

            DbCommandDefinition definition = createDbCommandDefinitionFunction(wrapperManifest.WrappedProviderManifest, commandTree);
            return this.CreateCommandDefinitionWrapper(definition, commandTree);
        }
		/// <summary>
		/// Initializes a new instance of the DbProviderManifestWrapper class.
		/// </summary>
		/// <param name="wrapperProviderInvariantName">Wrapper provider invariant name.</param>
		/// <param name="providerInvariantName">Provider invariant name.</param>
		/// <param name="wrappedProviderManifest">The wrapped provider manifest.</param>
		public DbProviderManifestWrapper(
			string wrapperProviderInvariantName,
			string providerInvariantName,
			DbProviderManifest wrappedProviderManifest)
		{
			this.wrapperProviderInvariantName = wrapperProviderInvariantName;
			this.providerInvariantName = providerInvariantName;
			this.wrappedProviderManifest = wrappedProviderManifest;
		}
        protected override DbCommandDefinition CreateDbCommandDefinition(
            DbProviderManifest providerManifest, DbCommandTree commandTree)
        {
            if (commandTree == null)
                throw new ArgumentNullException("commandTree");

            SqlGenerator generator = null;
            if (commandTree is DbQueryCommandTree)
                generator = new SelectGenerator();
            else if (commandTree is DbInsertCommandTree)
                generator = new InsertGenerator();
            else if (commandTree is DbUpdateCommandTree)
                generator = new UpdateGenerator();
            else if (commandTree is DbDeleteCommandTree)
                generator = new DeleteGenerator();
            else if (commandTree is DbFunctionCommandTree)
                generator = new FunctionGenerator();

            string sql = generator.GenerateSQL(commandTree);

            EFMySqlCommand cmd = new EFMySqlCommand();
            cmd.CommandText = sql;
            if (generator is FunctionGenerator)
                cmd.CommandType = (generator as FunctionGenerator).CommandType;

            SetExpectedTypes(commandTree, cmd);

            EdmFunction function = null;
            if (commandTree is DbFunctionCommandTree)
                function = (commandTree as DbFunctionCommandTree).EdmFunction;

            // Now make sure we populate the command's parameters from the CQT's parameters:
            foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters)
            {
                DbParameter parameter = cmd.CreateParameter();
                parameter.ParameterName = queryParameter.Key;
                parameter.Direction = ParameterDirection.Input;
                parameter.DbType = Metadata.GetDbType(queryParameter.Value);

                FunctionParameter funcParam;
                if (function != null &&
                    function.Parameters.TryGetValue(queryParameter.Key, false, out funcParam))
                {
                    parameter.ParameterName = funcParam.Name;
                    parameter.Direction = Metadata.ModeToDirection(funcParam.Mode);
                    parameter.DbType = Metadata.GetDbType(funcParam.TypeUsage);
                }
                cmd.Parameters.Add(parameter);
            }

            // Now add parameters added as part of SQL gen
            foreach (DbParameter p in generator.Parameters)
                cmd.Parameters.Add(p);

            return CreateCommandDefinition(cmd);
        }
        public LegacyDbProviderManifestWrapper(Legacy.DbProviderManifest wrappedProviderManifest)
        {
            Debug.Assert(wrappedProviderManifest != null, "wrappedProviderManifest != null");

            _wrappedProviderManifest = wrappedProviderManifest;

            _legacyStoreTypes = _wrappedProviderManifest.GetStoreTypes().ToArray();
            _storeTypes       =
                new ReadOnlyCollection <PrimitiveType>(
                    _legacyStoreTypes.Select(t => ConvertFromLegacyStoreEdmType(t, this)).ToList());
        }
        public LegacyDbProviderManifestWrapper(Legacy.DbProviderManifest wrappedProviderManifest)
        {
            Debug.Assert(wrappedProviderManifest != null, "wrappedProviderManifest != null");

            _wrappedProviderManifest = wrappedProviderManifest;

            _legacyStoreTypes = _wrappedProviderManifest.GetStoreTypes().ToArray();
            _storeTypes =
                new ReadOnlyCollection<PrimitiveType>(
                    _legacyStoreTypes.Select(t => ConvertFromLegacyStoreEdmType(t, this)).ToList());
        }
        // used by EntityStoreSchemaGenerator to start with an empty (primitive types only) StoreItemCollection and 
        // add types discovered from the database
        internal StoreItemCollection(DbProviderFactory factory, DbProviderManifest manifest, string providerManifestToken)
            : base(DataSpace.SSpace)
        {
            Debug.Assert(factory != null, "factory is null");
            Debug.Assert(manifest != null, "manifest is null");

            _providerFactory = factory;
            _providerManifest = manifest;
            _providerManifestToken = providerManifestToken;
            _cachedCTypeFunction = new Memoizer<EdmFunction, EdmFunction>(ConvertFunctionSignatureToCType, null);
            LoadProviderManifest(_providerManifest, true /*checkForSystemNamespace*/);
        }
    public override IEnumerable<MigrationStatement> Generate(IEnumerable<MigrationOperation> migrationOperations, string providerManifestToken)
    {
      List<MigrationStatement> stmts = new List<MigrationStatement>();
      MySqlConnection con = new MySqlConnection();
      providerManifest = DbProviderServices.GetProviderServices(con).GetProviderManifest(providerManifestToken);

      foreach (MigrationOperation op in migrationOperations)
      {
        OpDispatcher opdis = dispatcher[op.GetType().Name];
        stmts.Add(opdis(op));
      }
      return stmts;
    }
        public static DbProviderInfo GetProviderInfo(
            this DbConnection connection, out DbProviderManifest providerManifest)
        {
            //Contract.Requires(connection != null);

            var providerServices = DbProviderServices.GetProviderServices(connection);
            var providerManifestToken = providerServices.GetProviderManifestTokenChecked(connection);
            var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken);

            providerManifest = providerServices.GetProviderManifest(providerManifestToken);

            return providerInfo;
        }
        /// <summary>
        /// The constructor for PrimitiveType.  It takes the required information to identify this type.
        /// </summary>
        /// <param name="name">The name of this type</param>
        /// <param name="namespaceName">The namespace name of this type</param>
        /// <param name="version">The version of this type</param>
        /// <param name="dataSpace">dataSpace in which this primitive type belongs to</param>
        /// <param name="baseType">The primitive type that this type is derived from</param>
        /// <param name="providerManifest">The ProviderManifest of the provider of this type</param>
        /// <exception cref="System.ArgumentNullException">Thrown if name, namespaceName, version, baseType or providerManifest arguments are null</exception>
        internal PrimitiveType(string name,
                             string namespaceName,
                             DataSpace dataSpace,
                             PrimitiveType baseType,
                             DbProviderManifest providerManifest)
            : base(name, namespaceName, dataSpace)
        {
            EntityUtil.GenericCheckArgumentNull(baseType, "baseType");
            EntityUtil.GenericCheckArgumentNull(providerManifest, "providerManifest");

            this.BaseType = baseType;

            Initialize(this, baseType.PrimitiveTypeKind,
                false, // isDefault
                providerManifest);
        }
        internal override void Configure(
            IEnumerable<Tuple<DbEdmPropertyMapping, DbTableMetadata>> propertyMappings,
            DbProviderManifest providerManifest,
            bool allowOverride = false)
        {
            base.Configure(propertyMappings, providerManifest, allowOverride);

            propertyMappings
                .Each(
                    pm =>
                        {
                            if (IsRowVersion != null)
                            {
                                pm.Item1.Column.Facets.MaxLength = null;
                            }
                        });
        }
        /// <summary>
        ///     Converts a set of migration operations into Microsoft SQL Server specific SQL.
        /// </summary>
        /// <param name = "migrationOperations">The operations to be converted.</param>
        /// <param name = "providerManifestToken">Token representing the version of SQL Server being targeted (i.e. "2005", "2008").</param>
        /// <returns>A list of SQL statements to be executed to perform the migration operations.</returns>
        public override IEnumerable<MigrationStatement> Generate(
            IEnumerable<MigrationOperation> migrationOperations, string providerManifestToken)
        {
            _statements = new List<MigrationStatement>();
            _generatedSchemas = new HashSet<string>();
            _variableCounter = 0;

            using (var connection = CreateConnection())
            {
                _providerManifest
                    = DbProviderServices.GetProviderServices(connection)
                        .GetProviderManifest(providerManifestToken);
            }

            migrationOperations.Each<dynamic>(o => Generate(o));

            return _statements;
        }
Example #20
0
 /// <summary>
 /// Create a Command Definition object given a command tree.
 /// </summary>
 /// <param name="commandTree">command tree for the statement</param>
 /// <returns>an exectable command definition object</returns>
 /// <remarks>
 /// This method simply delegates to the provider's implementation of CreateDbCommandDefinition.
 /// </remarks>
 public DbCommandDefinition CreateCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
 {
     try
     {
         return CreateDbCommandDefinition(providerManifest, commandTree);
     }
     catch (ProviderIncompatibleException)
     {
         throw;
     }
     catch (Exception e)
     {
         if (EntityUtil.IsCatchableExceptionType(e))
         {
             throw EntityUtil.ProviderIncompatible(Strings.ProviderDidNotCreateACommandDefinition, e);
         }
         throw;
     }
 }
        /// <summary>
        /// Create a Command Definition object given a command tree.
        /// </summary>
        /// <param name="commandTree">command tree for the statement</param>
        /// <returns>an executable command definition object</returns>
        /// <remarks>
        /// This method simply delegates to the provider's implementation of CreateDbCommandDefinition.
        /// </remarks>
        public DbCommandDefinition CreateCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
        {
            //Contract.Requires(providerManifest != null);
            //Contract.Requires(commandTree != null);

            try
            {
                return CreateDbCommandDefinition(providerManifest, commandTree);
            }
            catch (ProviderIncompatibleException)
            {
                throw;
            }
            catch (Exception e)
            {
                if (e.IsCatchableExceptionType())
                {
                    throw new ProviderIncompatibleException(Strings.ProviderDidNotCreateACommandDefinition, e);
                }
                throw;
            }
        }
        internal static List<EdmSchemaError> LoadItems(DbProviderManifest manifest, IList<Schema> somSchemas,
            ItemCollection itemCollection)
        {

            List<EdmSchemaError> errors = new List<EdmSchemaError>();
            // Convert the schema, if model schema, then we use the EDM provider manifest, otherwise use the
            // store provider manifest
            IEnumerable<GlobalItem> newGlobalItems = LoadSomSchema(somSchemas, manifest, itemCollection);
            List<String> tempCTypeFunctionIdentity = new List<string>();

            // No errors, so go ahead and add the types and make them readonly
            foreach (GlobalItem globalItem in newGlobalItems)
            {
                // If multiple function parameter and return types expressed in SSpace map to the same
                // CSpace type (e.g., SqlServer.decimal and SqlServer.numeric both map to Edm.Decimal),
                // we need to guard against attempts to insert duplicate functions into the collection.
                //
                if (globalItem.BuiltInTypeKind == BuiltInTypeKind.EdmFunction && globalItem.DataSpace == DataSpace.SSpace)
                {
                    EdmFunction function = (EdmFunction)globalItem;

                    StringBuilder sb = new StringBuilder();
                    EdmFunction.BuildIdentity(
                        sb,
                        function.FullName,
                        function.Parameters,
                        // convert function parameters to C-side types
                        (param) => MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(param.TypeUsage),
                        (param) => param.Mode);
                    string cTypeFunctionIdentity = sb.ToString();

                    // Validate identity
                    if (tempCTypeFunctionIdentity.Contains(cTypeFunctionIdentity))
                    {

                        errors.Add(
                            new EdmSchemaError(
                                Strings.DuplicatedFunctionoverloads(function.FullName, cTypeFunctionIdentity.Substring(function.FullName.Length)).Trim()/*parameters*/,
                                (int)ErrorCode.DuplicatedFunctionoverloads,
                                EdmSchemaErrorSeverity.Error));
                        continue;
                    }

                    tempCTypeFunctionIdentity.Add(cTypeFunctionIdentity);
                }
                globalItem.SetReadOnly();
                itemCollection.AddInternal(globalItem);
            }
            return errors;
        }
 /// <summary>
 /// Load metadata from a SOM schema directly
 /// </summary>
 /// <param name="somSchema">The SOM schema to load from</param>
 /// <param name="providerManifest">The provider manifest used for loading the type</param>
 /// <param name="itemCollection">item collection in which primitive types are present</param>
 /// <returns>The newly created items</returns>
 internal static IEnumerable<GlobalItem> LoadSomSchema(IList<Schema> somSchemas,
                                                       DbProviderManifest providerManifest,
                                                       ItemCollection itemCollection)
 {
     IEnumerable<GlobalItem> newGlobalItems = Converter.ConvertSchema(somSchemas,
         providerManifest, itemCollection);
     return newGlobalItems;
 }
 internal static bool IsSystemNamespace(DbProviderManifest manifest, string namespaceName)
 {
     if (manifest == MetadataItem.EdmProviderManifest)
     {
         return (namespaceName == EdmConstants.TransientNamespace ||
                 namespaceName == EdmConstants.EdmNamespace ||
                 namespaceName == EdmConstants.ClrPrimitiveTypeNamespace);
     }
     else
     {
         return (namespaceName == EdmConstants.TransientNamespace ||
                 namespaceName == EdmConstants.EdmNamespace ||
                 namespaceName == EdmConstants.ClrPrimitiveTypeNamespace ||
                 (manifest != null && namespaceName == manifest.NamespaceName));
     }
 }
        /// <summary>
        /// Load stuff from xml readers - this now includes XmlReader instances created over embedded
        /// resources. See the remarks section below for some useful information.
        /// </summary>
        /// <param name="xmlReaders">A list of XmlReader instances</param>
        /// <param name="dataModelOption">whether this is a entity data model or provider data model</param>
        /// <param name="providerManifest">provider manifest from which the primitive type definition comes from</param>
        /// <param name="itemCollection">item collection to add the item after loading</param>
        /// <param name="computeFilePaths">Indicates whether the method should bother with the file paths; see remarks below</param>
        /// <remarks>
        /// In order to accommodate XmlReaders over artifacts embedded as resources in assemblies, the
        /// notion of a filepath had to be abstracted into a URI. In reality, however, a res:// URI that
        /// points to an embedded resource does not constitute a valid URI (i.e., one that can be parsed
        /// by the System.Uri class in the .NET framework). In such cases, we need to supply a list of
        /// "filepaths" (which includes res:// URIs), instead of having this method create the collection.
        /// This distinction is made by setting the 'computeFilePaths' flags appropriately.
        /// </remarks>
        internal static IList<EdmSchemaError> LoadItems(IEnumerable<XmlReader> xmlReaders,
                                                       IEnumerable<string> sourceFilePaths,
                                                       SchemaDataModelOption dataModelOption,
                                                       DbProviderManifest providerManifest,
                                                       ItemCollection itemCollection,
                                                       bool throwOnError)
        {
            IList<Schema> schemaCollection = null;

            // Parse and validate all the schemas - since we support using now,
            // we need to parse them as a group
            var errorCollection = SchemaManager.ParseAndValidate(xmlReaders, sourceFilePaths,
                dataModelOption, providerManifest, out schemaCollection);

            // Try to initialize the metadata if there are no errors
            if (MetadataHelper.CheckIfAllErrorsAreWarnings(errorCollection))
            {
                List<EdmSchemaError> errors = LoadItems(providerManifest, schemaCollection, itemCollection);
                foreach (var error in errors)
                {
                    errorCollection.Add(error);
                }
            }
            if (!MetadataHelper.CheckIfAllErrorsAreWarnings(errorCollection) && throwOnError)
            {
                //Future Enhancement: if there is an error, we throw exception with error and warnings.
                //Otherwise the user has no clue to know about warnings.
                throw EntityUtil.InvalidSchemaEncountered(Helper.CombineErrorMessage(errorCollection));
            }
            return errorCollection;
        }
Example #26
0
 protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest manifest, DbCommandTree commandTree)
 {
     DbCommand prototype = CreateCommand(manifest, commandTree);
     DbCommandDefinition result = this.CreateCommandDefinition(prototype);
     return result;
 }
Example #27
0
        /// <summary>
        /// Create a SampleCommand object, given the provider manifest and command tree
        /// </summary>
        private DbCommand CreateCommand(DbProviderManifest manifest, DbCommandTree commandTree)
        {
            if (manifest == null)
                throw new ArgumentNullException("manifest");

            if (commandTree == null)
                throw new ArgumentNullException("commandTree");

            SampleProviderManifest sampleManifest = (manifest as SampleProviderManifest);
            if (sampleManifest == null)
            {
                throw new ArgumentException("The provider manifest given is not of type 'SampleProviderManifest'.");
            }

            StoreVersion version = sampleManifest.Version;

            SampleCommand command = new SampleCommand();

            List<DbParameter> parameters;
            CommandType commandType;

            command.CommandText = SqlGenerator.GenerateSql(commandTree, version, out parameters, out commandType);
            command.CommandType = commandType;

            if (command.CommandType == CommandType.Text)
            {
                command.CommandText += Environment.NewLine + Environment.NewLine + "-- provider: " + this.GetType().Assembly.FullName;
            }

            // Get the function (if any) implemented by the command tree since this influences our interpretation of parameters
            EdmFunction function = null;
            if (commandTree is DbFunctionCommandTree)
            {
                function = ((DbFunctionCommandTree)commandTree).EdmFunction;
            }

            // Now make sure we populate the command's parameters from the CQT's parameters:
            foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters)
            {
                SqlParameter parameter;

                // Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and 
                // type trump user-defined facets and type in the EntityCommand).
                FunctionParameter functionParameter;
                if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter))
                {
                    parameter = CreateSqlParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value);
                }
                else
                {
                    parameter = CreateSqlParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value);
                }

                command.Parameters.Add(parameter);
            }

            // Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which
            // does not support user parameters, where there is no risk of name collision)
            if (null != parameters && 0 < parameters.Count)
            {
                if (!(commandTree is DbInsertCommandTree) &&
                    !(commandTree is DbUpdateCommandTree) &&
                    !(commandTree is DbDeleteCommandTree))
                {
                    throw new InvalidOperationException("SqlGenParametersNotPermitted");
                }

                foreach (DbParameter parameter in parameters)
                {
                    command.Parameters.Add(parameter);
                }
            }

            return command;
        }
 public static IList<EdmSchemaError> ParseAndValidate(IEnumerable<XmlReader> xmlReaders,
     IEnumerable<string> sourceFilePaths, SchemaDataModelOption dataModel,
     DbProviderManifest providerManifest,
     out IList<Schema> schemaCollection)
 {
     return ParseAndValidate(xmlReaders, 
         sourceFilePaths, 
         dataModel,
         NoOpAttributeValueNotification,
         NoOpAttributeValueNotification,
         delegate(Action<string, ErrorCode, EdmSchemaErrorSeverity> addError) { return providerManifest == null ? MetadataItem.EdmProviderManifest : providerManifest; },
         out schemaCollection);
 }
Example #29
0
 protected abstract DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree);
        private IList<EdmSchemaError> Init(IEnumerable<XmlReader> xmlReaders,
                                           IEnumerable<string> filePaths, bool throwOnError,
                                           out DbProviderManifest providerManifest,
                                           out DbProviderFactory providerFactory,
                                           out string providerManifestToken,
                                           out Memoizer<EdmFunction, EdmFunction> cachedCTypeFunction)
        {
            EntityUtil.CheckArgumentNull(xmlReaders, "xmlReaders");
            // 'filePaths' can be null

            cachedCTypeFunction = new Memoizer<EdmFunction, EdmFunction>(ConvertFunctionSignatureToCType, null);

            Loader loader = new Loader(xmlReaders, filePaths, throwOnError);
            providerFactory = loader.ProviderFactory;
            providerManifest = loader.ProviderManifest;
            providerManifestToken = loader.ProviderManifestToken;

            // load the items into the colleciton
            if (!loader.HasNonWarningErrors)
            {
                LoadProviderManifest(loader.ProviderManifest, true /* check for system namespace */);
                List<EdmSchemaError> errorList = EdmItemCollection.LoadItems(_providerManifest, loader.Schemas, this);
                foreach (var error in errorList)
                {
                    loader.Errors.Add(error);
                }
                
                if (throwOnError && errorList.Count != 0)
                    loader.ThrowOnNonWarningErrors();
            }
            
            return loader.Errors;
        }
 protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree)
 {
     return new GlimpseProfileDbCommandDefinition(InnerProviderServices.CreateCommandDefinition(commandTree), Stats);
 }
        /// <summary>
        /// checks if the schemaKey refers to the provider manifest schema key 
        /// and if true, loads the provider manifest
        /// </summary>
        /// <param name="connection">The connection where the store manifest is loaded from</param>
        /// <param name="checkForSystemNamespace">Check for System namespace</param>
        /// <returns>The provider manifest object that was loaded</returns>
        private void LoadProviderManifest(DbProviderManifest storeManifest,
                                                      bool checkForSystemNamespace)
        {

            foreach (PrimitiveType primitiveType in storeManifest.GetStoreTypes())
            {
                //Add it to the collection and the primitive type maps
                this.AddInternal(primitiveType);
                _primitiveTypeMaps.Add(primitiveType);
            }

            foreach (EdmFunction function in storeManifest.GetStoreFunctions())
            {
                AddInternal(function);
            }
        }