Professional Documents
Culture Documents
Essentials
3. Data Flow Task definition: The Data Flow task is a pipeline in which data is
picked up, processed, and written to a destination. The key characteristic of the
pipeline is defined by the task’s name: The data flows through the pipeline in
memory. An implication of the data flow pipeline architecture is that avoiding I/O
provides excellent performance, subject to the memory characteristics of the
physical system.
Data Sources
There are several kinds of predefined source adapters, called Data Flow Sources in the
toolbox pane:
• Use the OLE DB Source adapter to extract data from any source that has an OLE
DB provider, including SQL Server, Oracle, and DB2. You can source from a
table or view, or from a SQL query or stored procedure. You may source from a
query or stored procedure if your source table is huge and you want only a
relatively small number of rows. Figure 5.3 depicts a data flow that uses an OLE
DB data source.
• Use the DataReader Source adapter to extract data from a .NET Provider like
ADONET:SQL or ADONET:ORACLE. You’ll probably use an OLE DB provider
instead, even for sourcing data from SQL Server because it has a nicer user
interface. If performance is vital, use the DataReader source adapter, which has
slightly better performance than the OLE DB adapter, but only the most basic user
interface.
• The Flat File Source adapter pulls data from a flat file. You could use an OLE
DB or ODBC flat file driver, but we prefer the Flat File Source because it has a
better UI and handles bad data more flexibly.
• The Raw File Source adapter pulls data from a raw data file, which is a format
unique to Integration Services. Integration Services writes data to and reads data
from the raw format very efficiently. Raw files are a great format to use for data
staging, for example to store data extracts during the day (or month) until the
main transformation logic kicks off. Also use raw files to hold a fast “backup” of
the dimension tables or fact rows that will be updated during an ETL operation.
• The XML Source adapter pulls data from an XML source. The XML source can
be either in a file or in a package variable (which, presumably, you set in an
earlier task in the package). You can optionally apply an XSD schema definition
against the XML data. You should hesitate to take any XML data that doesn’t
have a schema! Because XML data is so unstructured, the source adapter lets you
break out the data into multiple destinations. These might flow into different
tables, or be handled in different ways before being recombined into a single
table.
• You can define a custom source adapter to consume data from a unique source,
like a file whose rows have different formats under different conditions. For a
single-time use, you could use the Script transform to write the source adapter. To
easily re-use the custom adapter, develop it in any VS.NET language and install
the custom adapter into the list of data flow transformations, as described in
Books Online.
Data Destinations
There are several kinds of predefined destination adapters, called Data Flow Destinations.
These are available in the same toolbox illustrated in Figure 5.3, simply by scrolling
down in the toolbox list.
• The OLE DB destination adapter will load data into any OLE DB target database
or table, like SQL Server, Oracle, DB2, or even Excel. If you are loading a large
volume of data into non-SQL Server OLE DB destination, it’s usually more
efficient to write the data as a flat file and use the Execute Process control flow
task to invoke the target database’s bulk loader.
• You can use the SQL Server destination adapter to load data into the SQL Server
relational database, instead of the OLE DB adapter. There are several differences
between the two adapters:
o The SQL Server adapter can write data only to a SQL Server relational
database running on the same machine as Integration Services.
o The SQL Server adapter requires that data be formatted perfectly; it skips
some data checking and conversion steps that the OLE DB adapter
performs for you.
o The SQL Server adapter can perform faster than the OLE DB adapter
because it skips those data checking and conversion steps.
o Unlike the OLE DB adapter, the SQL Server adapter doesn’t let you set a
batch size or commit size for bulk loading. In some scenarios, setting these
parameters optimally enables the OLE DB adapter to out-perform the SQL
Server adapter.
• Use OLE DB during the early stages of development because it’s more forgiving
of data type mismatches. Late in the development cycle, test the performance of
the two adapters to determine which you want to use in production.
• The Flat File and Raw File destination adapters write the data stream to the file
system. Use raw files if the data will be consumed only by Integration Services.
Flat files are a standard format appropriate for many uses.
• Use the Data Reader destination adapter to generate a Reporting Services report
directly from an Integration Services package. This feature enables an interesting
use of Integration Services for real-time DW/BI systems, as we discuss in Chapter
17.
• The Recordset destination adapter populates an ADODB recordset object held in
memory.
• The SQL Mobile destination adapter is appropriate for pushing data down to SQL
Server Mobile Edition databases.
• The Dimension and Partition Processing destination adapters push the pipeline
data into an Analysis Services dimension or fact partition, without the usual
intermediate step of writing the data to a relational database. In this scenario, the
Analysis Services database is populated directly from the ETL data stream. This
feature is most interesting for real-time DW/BI systems.
• You can define a custom destination adapter to write data to a custom target, just
as you could develop a custom source adapter. We hope someone will develop a
flexible, high-performance Oracle destination.
Data Transformations
Between sources and destinations are the data transformation steps. These include:
• Conditional Split and Multicast transforms create multiple output streams from
one data stream. Use Conditional Split to define a condition that divides the data
stream into discrete pieces, for example based on a column’s value being greater
or less than 100. You can treat the split streams differently and recombine them
later, or you can use the Conditional Split to filter the data. The Multicast
transform efficiently replicates a stream, perhaps for parallel processing. The
Conditional Split transform sends each input row to one and only one output
stream; Multicast sends each input row to each output stream.
• The Union All, Merge, Merge Join, and Lookup transforms all join multiple data
streams. Use Union All to combine multiple streams with similar structures,
perhaps from an upstream Conditional Split, or for Customer records from
multiple source systems. Merge is very similar to Union All, but it interleaves
sorted rows. If you don’t care about the order of the rows in the output stream,
Union All is both more forgiving and more efficient. Merge Join is a lot like a
database join: it merges rows based on columns in common, and can perform a
left, full, or inner join. The Lookup transform is very useful for decoding a code
from the source data into a friendly label using information stored in a database
table. You’ll make heavy use of the Lookup transform in performing the surrogate
key assignment on your incoming fact data. The operations performed by these
four transforms could all be performed using SQL queries. But if the data is in the
pipeline it’s easier and almost always more efficient to use these transforms than
to write to a table and potentially index that table before performing a SQL query.
• Use the OLE DB Command transform to update or delete rows in a target table,
based on the data in the data flow. The OLE DB Command transformation
executes a SQL statement for each row in a data flow; the SQL statement is
usually parameterized. The OLE DB Command is the only way to execute an
UPDATE statement from within the Data Flow. If your ETL process requires a
large number of updates—most common for snapshot fact tables—you should
consider writing the target rows to a staging table and performing a bulk UPDATE
statement from the Execute SQL task in the Control Flow instead.
• The Row Count and Audit transforms are most useful for developing process
metadata about the data flow. Use the Row Count transform to efficiently count
the rows that will be loaded to the target, or that flow into the error handler. Audit
captures information about the system environment at the time the data flow task
is run, including the computer name, user id, and execution start time.
• You can use the Percentage Sampling and Row Sampling transforms during
package testing, to operate against a subset of the source data. You’ll also use
sampling to choose a random sample for deep analysis and data mining, and for
building your sandbox source system as described later in this chapter.
• The Pivot and Unpivot transforms will reduce or increase, respectively, the
number of rows in the data stream. Use the Unpivot transform to create 12 rows
of data from a single source row that has 12 columns holding a year’s worth of
monthly values.
• Use the Data Mining Model Training and Data Mining Query transforms to
incorporate Analysis Services data mining technology into your ETL application.
For example, you may have a Customer Score attribute in the Customer
dimension, whose value comes from a data mining model. These transforms will
compute that model and return the results into the data flow pipeline.
• Fuzzy Grouping and Fuzzy Lookup transforms employ fuzzy logic algorithms that
were developed by Microsoft Research. These are useful transforms for data
cleansing and de-duplication. Fuzzy Lookup, like the Lookup transform,
compares and matches two sets of data, but with a measure of confidence based
on semantic similarity. Fuzzy Grouping acts much the same way, but is used to
de-duplicate data on fuzzy criteria. Unlike third-party tools that perform
name/address matching based on a detailed history of addresses, these fuzzy
algorithms are based on semantics. You have to experiment with the settings, but
the transforms are valuable for a wide range of data cleansing problems.
• Term Extraction and Term Lookup transforms employ text-mining algorithms that
were also developed by Microsoft Research. Term Extraction is a text-mining
component which returns key terms from a document in a text column. Term
Lookup matches a document to key terms in a reference table.
• The File Extractor and File Injector transforms are used primarily to strip out
(extract) text and image data from a data flow and put it into a file or files, or to
add such data from files into the data flow.
• The Script component provides a simple mechanism for creating a custom
transformation in the Visual Studio for Applications environment. We include a
simple example of using the Script component in Chapter
Transformation components with asynchronous outputs cannot output rows until the
component has received all its input rows, or when the transformation does not produce
exactly one output row for each row received as input. The Aggregate transformation, for
example, cannot calculate a sum across rows until it has read all the rows.
6. Data Viewers:
Data viewers display data between two components in a data flow. Data viewers can
display data when the data is extracted from a data source and first enters a data flow,
before and after a transformation updates the data, and before the data is loaded into its
destination. To view the data, you attach data viewers to the path that connects two data
flow components. The ability to view data between data flow components makes it easier
to identify unexpected data values, view the way a transformation changes column
values, and discover the reason that a transformation fails. A data viewer can display data
in a grid, histogram, scatter plot, or column chart.
• Using a grid, you select the columns to display. The values for the selected
columns display in a tabular format.
• Using a histogram, you select the column to model in the histogram. A histogram
shows the distribution of numeric values and works only with numeric data.
• Using a scatter plot, you select the columns to appear on the x-axis and y-axis.
The scatter plot graph works only with numeric data.
• Using a chart format, you select the column to model with the column chart. The
column chart displays the occurrence count of discrete values in the selected
column.
7. Variables
Variables store values that a SQL Server 2005 Integration Services (SSIS) package and its
containers, tasks, and event handlers can use at run time. The scripts in the Script task and
the Script component can also use variables. The precedence constraints that sequence
tasks and containers into a workflow can use variables when their constraint definitions
include expressions.
You can use variables in Integration Services packages for the following purposes:
• Including an in-memory lookup table. For example, a package can run an Execute
SQL task that loads a variable with data values.
• Loading variables with data values and then using them to specify a search
condition in a WHERE clause. For example, a package can update the script in a
Script task or a Transact-SQL statement in an Execute SQL task.
• Loading a variable with an integer and then using the value to control looping
within a package control flow. For example, the evaluation expression in a For
Loop container can use a variable to control iteration.
• Building expressions that include variable values. For example, the Derived
Column transformation can populate a column with the result obtained by
multiplying a variable value by a column value.
Integration Services supports two types of variables: user-defined variables and system
variables. Package developers define user-defined variables, and system variables are
defined by Integration Services. You can create as many user-defined variables as a
package requires, but you cannot create additional system variables.
8. Connection Managers:
A package can use multiple instances of a connection manager type, and you can set the
properties on each instance. At run time, each instance of a connection manager type
creates a connection that has different attributes. The following table lists the connection
manager types.
9. Log Providers
Log providers are an important part of the IS logging infrastructure. Every IS object
has access to the logging infrastructure. Log providers are, yet again, pluggable
components that are responsible for taking log entries sent by components in the
package and writing them to the particular destination and medium they support. For
example, a stock XML log provider writes log entries to an XML file. Tasks and other
components are not aware of the destination to which they send their log entries. They
just send their logs to the IS runtime and the runtime routes the log to the configured
log providers. The log providers then take the log entries and convert them to the
correct format and save the log entries based on how they are configured. It's also
possible to log to more than one location at a time using two different log providers
simultaneously on the same package.
Precedence constraints link executables, containers, and tasks in packages into a control
flow, and specify conditions that determine whether executables run. An executable can
be a For Loop, Foreach Loop, or Sequence container; a task; or an event handler. Event
handlers also use precedence constraints to link their executables into a control flow.
A precedence constraint links two executables: the precedence executable and the
constrained executable. The precedence executable runs before the constrained
executable, and the execution result of the precedence executable may determine whether
the constrained executable runs. The following diagram shows two executables linked by
a precedence constraint.
11. Containers
Containers are objects in SQL Server 2005 Integration Services (SSIS) that provide
structure to packages and services to tasks. They support repeating control flows in
packages, and they group tasks and containers into meaningful units of work. Containers
can include other containers in addition to tasks.
• Repeat tasks for each element in a collection, such as files in a folder, schemas, or
SQL Management Objects (SMO) objects. For example, a package can run
Transact-SQL statements that reside in multiple files.
• Group tasks and containers that must succeed or fail as a unit. For example, a
package can group tasks that delete and add rows in a database table, and then
commit or roll back all the tasks when one fails.
Integration Services provides four types of containers for building packages. The
following table lists the container types.
Container Description
Foreach Loop
Runs a control flow repeatedly by using an enumerator.
Container
For Loop Container Runs a control flow repeatedly by testing a condition.
Groups tasks and containers into control flows that are subsets of the
Sequence Container
package control flow.
Task Host Container Provides services to a single task.
Following are the main differences between data flow and control flow:
• Execution model
• Connecting lines
• Functional gamut
Execution Model: Data flow and workflow components execute differently. The
duration of a given task's execution time is a fraction of the total duration of the
execution time of the package it runs within. Adding together the execution duration
times from each of the individual tasks can closely approximate the total package
execution duration. Of course, this is complicated when there is more than one
logically parallel executing thread. Then, the execution duration of the package is the
execution duration of the longest logical thread duration. In addition, tasks on the
same logical thread don't run at the same time. Estimating the total execution
duration of a Data Flow Task is a little more complicated, but conceptually it is driven
by the amount of data running through the Data Flow Task and the types of
transforms in the Data Flow Task. The significant difference is that it's possible for all
adapters and transforms on one logical thread to be active at the same time.
Connecting lines: Tasks have precedence constraints. Transforms have paths. Those
connecting lines look a lot alike, but they're very different. Precedence constraints as
described previously do little but determine if the next task can execute. Paths
actually represent outputs of transforms and the metadata associated with those
outputs. Precedence constraints control task execution; paths show where the data
flows .
Functional gamut: The functional gamut of tasks is virtually unlimited. Tasks can be
written to do just about anything any piece of software can do. Witness the stock tasks
that ship with IS that vary from the Script Task, which, in itself, represents the key to
unlock the full power of .Net software development, to the Data Flow Task. The
Windows Management Instrumentation (WMI) and Web Services Tasks are other
good examples of the range of different tasks you can write that use various emerging
technologies. Transforms, on the other hand, are very specific to processing data and
are strictly bound to the architecture of the Data Flow Task. This isn't to say that it is a
deficit for transforms, but merely to point out that tasks and transforms are quite
different. The beauty of these differences is that both are supported within one
framework and both are equally extensible through pluggable architectures.
The Taskhost is a very dedicated sort of container. Taskhosts live and die with the
tasks they contain. Every instance of a task has a Taskhost surrounding it, servicing
it, protecting it, and controlling it. When the task is deleted, the Taskhost goes with
it. Yet, when viewed within the designer, the task is all you see, whereas the
Taskhost is mostly invisible.
13. Packages
For example, a data conversion fails because a column contains a string instead of a
number, an insertion into a database column fails because the data is a date and the
column has a numeric data type, or an expression fails to evaluate because a column
value is zero, resulting in a mathematical operation that is not valid.
Many data flow components support error outputs, which let you control how the
component handles row-level errors in both incoming and outgoing data. You specify
how the component behaves when truncation or an error occurs by setting options on
individual columns in the input or output.
For example, you can specify that the component should fail if customer name data is
truncated, but ignore errors on another column that contains less important data.
SSIS includes logging features that write log entries when run-time events occur and
can also write custom messages.
Integration Services supports a diverse set of log providers, and gives you the ability
to create custom log providers. The Integration Services log providers can write log
entries to text files, SQL Server Profiler, SQL Server, Windows Event Log, or XML
files.
Logs are associated with packages and are configured at the package level. Each task
or container in a package can log information to any package log. The tasks and
containers in a package can be enabled for logging even if the package itself is not.
To customize the logging of an event or custom message, Integration Services
provides a schema of commonly logged information to include in log entries. The
Integration Services log schema defines the information that you can log. You can
select elements from the log schema for each log entry.
• Avoid repeating the downloading and uploading of large files. For example, a
package that downloads multiple large files by using an FTP task for each
download can be restarted after the downloading of a single file fails and then
download only that file.
• Avoid repeating the loading of large amounts of data. For example, a package
that performs bulk inserts into dimension tables in a data warehouse using a
different Bulk Insert task for each dimension can be restarted if the insertion
fails for one dimension table, and only that dimension will be reloaded.
A package can be restarted only at the control flow level. You cannot restart a
package in the middle of a data flow. To avoid rerunning the whole data flow, the
package might be designed to include multiple data flows, each one using a
different Data Flow task. This way the package can be restarted, rerunning only
one Data Flow task.
The Integration Services run-time engine allows packages, tasks, and other types
of containers to be suspended during execution by using breakpoints. The use of
breakpoints lets you review and correct errors that prevent your application or
tasks from running correctly. The breakpoint architecture enables the client to
evaluate the run-time value of objects in the package at defined points of
execution, and to decide if the task processing should suspend. Custom task
developers can utilize this architecture to create custom breakpoints by using the
IDTSBreakpointSite interface, and its parent class, the IDTSSuspend interface.
The IDTSBreakpointSite interface defines the interaction between the run-time
engine and the task for creating and managing custom breakpoints. The
IDTSSuspend interface provides methods and properties that are called by the
run-time engine to notify the task to suspend its execution.
SQL Server 2005 Integration Services (SSIS) provides package configurations for
updating the values of properties at run time. Using configurations you can create
packages, set properties on package objects during package development, and
then add the configuration to the package to update the properties at run time. For
example, you can update the values of variables or the connection strings of
connection managers.
Type Description
XML An XML file contains the configurations. The XML file can include
configuration file multiple configurations.
Environment
An environment variable contains the configuration.
variable
Registry entry A registry entry contains the configuration.
Parent package A variable in the package contains the configuration. This configuration
variable type is typically used to update properties in called packages.
A table in a SQL Server database contains the configuration. The table
SQL Server table
can include multiple configurations
Deployment is really about getting the destination machine to "look" like the
machine where the package was built. If the package references a custom task,
user account, configuration file, or share on the development machine, the custom
task, user account, configuration file, and share must be available on the
destination machine. The designer provides a way to bundle the project packages
and miscellaneous files into a folder that you can copy to another machine. The
Deployment Utility is a small executable that knows how to install the bundle.
The deployment utility is created on the computer on which the Integration
Services project is stored.
Packages can be saved either in the sysdtspackages90 table in the SQL Server
msdb database or in the file system.
You can import and export packages between the following storage types:
• Folders in the SSIS Package Store. The two default folders are named File
System and MSDB.
Integration Services gives you the ability to import and export packages, and by
doing this change the storage format and location of packages. Using the import
and export features, you can add packages to the file system, package store, or
msdb database, and copy packages from one storage format to another. For
example, packages saved in msdb can be copied to the file system and vice versa.
The following table describes the protection levels that Integration Services
provides.
The following table describes the read and write actions of the fixed database-
level roles in Integration Services.
The sysdtspackages90 table in msdb contains the packages that are saved to SQL
Server. The sysdtspackages90 table includes columns that contain information about
the roles that are assigned to packages.
• The readerrole column specifies the role that has read access to the package.
• The writerrole column specifies the role that has write access to the package.
• The ownersid column contains the unique security identifier of the user who
created the package. This column defines the owner of the package.
Microsoft SQL Server 2005 Integration Services (SSIS) includes the Integration
Services service, a Windows service for managing Integration Services packages.
The Integration Services service is available only in SQL Server Management
Studio.
The Integration Services service is not required if you only want to design and
execute Integration Services packages. However, the service is required to list and
monitor packages using SQL Server Management Studio. You manage Integration
Services service using Services, a Microsoft Management Console (MMC) snap-
in.
The dtutil command prompt utility is used to manage SQL Server 2005 Integration
Services (SSIS) packages. The utility can copy, move, delete, or verify the existence of a
package. These actions can be performed on any SSIS package that is stored in one of
three locations: a Microsoft SQL Server database, the SSIS Package Store, and the file
system. The package and its storage type are identified by the /SQL, /FILE, and /DTS
options.
Syntax
dtutil /option [value] [/option [value]]...
Parameters
Option Description
/? Displays the command prompt options.
Copies an SSIS package:
• The sourcePathandPackageName
argument specifies where the SSIS
package is copied from.
• The
destinationPathandPackageName
argument specifies where the SSIS
package is copied to. If the
/C[opy] {SQL | FILE | DTS}; destination is SQL, the DestUser,
sourcePathandPackageName {SQL | FILE | DestPassword and DestServer
DTS}; destinationPathandPackageName arguments must also be specified in
the command.
Note:
When possible, use Windows
Authentication..
Specifies the server name used with any
action that causes a destination to be saved to
SQL Server. It is used to identify a non-local
or non-default server when saving an SSIS
package. It is an error to specify
DESTSERVER in a command line that does
not have an action associated with SQL
/DestS[erver] server_instance Server. Actions such as SIGN SQL, COPY
SQL, or MOVE SQL options would be
appropriate commands to combine with this
option.
• FILE
• SQL
• SOURCEUSER
• SOURCEPASSWORD
• SOURCESQLSERVER
ProtectionLevel options:
/En[crypt] {SQL | FILE};
Path;ProtectionLevel[;password] Level 0: Strips sensitive information.
• SQL
• SOURCEUSER
• SOURCEPASSWORD
• SOURCESQLSERVER
dtutil /H
/H[elp] option
The following two examples show how to
use the /H option to display extended help
for a specific option, the /Q [uiet] option, in
this example:
dtutil /H Q
Creates a new GUID for the package and
updates the package ID property. When a
package is copied, the package ID remains
/I[DRegenerate] the same; therefore, the log files contain the
same GUID for both packages. This action
creates a new GUID for the newly-copied
package to distinguish it from the original.
/M[ove] {SQL | File | DTS}; path Moves an SSIS package. This action uses
two arguments, which are separated by a
semicolon:
Note:
When possible, use Windows
Authentication..
Specifies the server name used with the SQL
option to enable the retrieval of an SSIS
package that is stored in SQL Server. It is an
error to specify SOURCESQLSERVER in a
command line that does not include the
/SourceS[erver] server_instance SIGN SQL, COPY SQL, or MOVE SQL
option.
Note:
When possible, use Windows
Authentication..
/SQ[L] package_path Specifies the location of an SSIS package.
This option indicates that the package is
stored in the msdb database. The
package_path argument specifies the path
and name of the SSIS package. Folder names
are terminated with back slashes.
• FILE
• SOURCEUSER
• SOURCEPASSWORD
• SOURCESQLSERVER
Important:
Do not use a blank password. Use a strong
password.
To create a job, a user must be a member of one of the SQL Server Agent fixed
database roles or the sysadmin fixed server role. A job can be edited only by its
owner or members of the sysadmin role. For more information about the SQL
Server Agent fixed database roles. Jobs can be written to run on the local instance
of SQL Server or on multiple instances across an enterprise. To run jobs on
multiple servers, you must set up at least one master server and one or more target
servers.
30. What are the SQL servers Agent fixed database roles?
SQL Server 2005 introduces the following msdb database fixed database roles, which
give administrators finer control over access to SQL Server Agent. The roles listed
from least to most privileged access are:
• SQLAgentUserRole
• SQLAgentReaderRole
• SQLAgentOperatorRole
When users who are not members of one of these roles are connected to SQL Server
in SQL Server Management Studio, the SQL Server Agent node in Object Explorer
is not visible. A user must be a member of one of these fixed database roles or a
member of the sysadmin fixed server role to use SQL Server Agent.
31.What are the permissions of SQL server agent fixed database roles?
SQLAgentUserRole Permissions
SQLAgentUserRole is the least privileged of the SQL Server Agent fixed database roles.
It has permissions on only operators, local jobs, and job schedules. Members of
SQLAgentUserRole have permissions on only local jobs and job schedules that they
own. They cannot use multiserver jobs (master and target server jobs), and they cannot
change job ownership to gain access to jobs that they do not already own.
SQLAgentUserRole members can view a list of available proxies only in the Job Step
Properties dialog box of SQL Server Management Studio. Only the Jobs node in SQL
Server Management Studio Object Explorer is visible to members of
SQLAgentUserRole.
SQLAgentReaderRole Permissions
SQLAgentOperatorRole Permissions
SQLAgentOperatorRole is the most privileged of the SQL Server Agent fixed database
roles. It includes all the permissions of SQLAgentUserRole and
SQLAgentReaderRole. Members of this role can also view properties for operators and
proxies, and enumerate available proxies and alerts on the server.
SQLAgentOperatorRole members have additional permissions on local jobs and
schedules. They can execute, stop, or start all local jobs, and they can delete the job
history for any local job on the server. They can also enable or disable all local jobs and
schedules on the server. To enable or disable local jobs or schedules, members of this role
must use the stored procedures sp_update_job and sp_update_schedule. Only the
parameters that specify the job or schedule name or identifier and the @enabled
parameter can be specified by members of SQLAgentOperatorRole. If they specify any
other parameters, execution of these stored procedures fails. SQLAgentOperatorRole
members cannot change job ownership to gain access to jobs that they do not already
own.
The Jobs, Alerts, Operators, and Proxies nodes in SQL Server Management Studio
Object Explorer are visible to members of SQLAgentOperatorRole. Only the Error
Logs node is not visible to members of this role.
32.
3. Integration Services Data Flow Engine : The data flow engine supports the data flow
task, which is a specialized, high performance task dedicated to moving and transforming
data from disparate sources. Unlike other tasks, the data flow task contains additional
objects called pipeline components. These components are the core "moving parts" of the
task. They define the movement and transformation of data. Programming the data flow
engine lets developers automate the creation and configuration of the components in a
data flow task, and create custom components.
4. Commonly Used Assemblies: The assemblies that are frequently used when
programming Integration Services using the .NET Framework are :
Assembly Description
Microsoft.SqlServer.Managed
Contains the managed run-time engine.
DTS.dll
Microsoft.SqlServer.Pipeline
The PIA for the data flow engine.
Wrapper.dll
Microsoft.SqlServer.Runtime
The PIA for the native run-time engine.
Wrapper.dll
Contains the PipelineComponent base
Microsoft.SqlServer.PipelineH
class, which is used to create custom data
ost.dll
flow components.
5. Four classes that are important to understand when developing custom tasks:
a. Task class - Defines an abstract class that implements the methods and properties
common to all tasks in Integration Services.
Namespace: Microsoft.SqlServer.Dts.Runtime
Assembly: Microsoft.SqlServer.ManagedDTS (in
microsoft.sqlserver.manageddts.dll)
b. TaskHost class- Provides a container that encapsulates a single task. In the SSIS
Designer, the TaskHost is not configured separately; instead, it is configured
when you set the properties of the task it encapsulates.
Namespace: Microsoft.SqlServer.Dts.Runtime
Assembly: Microsoft.SqlServer.ManagedDTS (in
microsoft.sqlserver.manageddts.dll)
Namespace: Microsoft.SqlServer.Dts.Runtime
Assembly: Microsoft.SqlServer.ManagedDTS (in
microsoft.sqlserver.manageddts.dll)
Namespace: Microsoft.SqlServer.Dts.Runtime.Design
Assembly: Microsoft.SqlServer.Dts.Design (in microsoft.sqlserver.dts.design.dll)
6. Objects where tasks can be added:
• Package
• Sequence
• ForLoop
• ForEachLoop
• DtsEventHandler