Showing posts with label Oracli 9i. Show all posts
Showing posts with label Oracli 9i. Show all posts

Oracle Architecture

Oracle Architecture

In Every Oracle Server consists of an Oracle Instance and Database .

An Oracle Instance is the combination of System Global Area(SGA) and the Background Process.

Background Process is two types
1) Mandatory
2) Optional

Mandatory are
1) Process Monitor (PMON)
2) System Monitor (SMON)
3) Database Writer (DBWR)
4) Log Writer (LGWR)
5) Checkpoint (CKPT)


Optional are
1) Oracle Parallel Query Option (OPQO)
2) Multi DBWR
3) Archiver (ARCH)
4) Recoverer (Reco)

Oracle Database consists mainly these files
1) Redo Log File
2) Control File
3) Data File
4) Parameter File
5) Initialisation File (init.ora)

Redo Log file:
It stores the changed information made by the Redolog buffer Cache by the help of Log Writer (LGWR).
-It stores the redo entries
-Atleast two files is required and the size should be in KB’s.
-It contains File Id- Block Id –New Contents

Data file:
- The actual data stores in the data file. The file size should be in MBs or GBs or may be TBs.
- One data file belongs only one Tablespace.
Control File:
It Stores the crushial information about the database like
- No of data files
- Name of each data files
- Location of each data files
- Database original creation date
Parameter File:
While datatabase is starting, first it reads from the parameter file, what parameter u have set in the database. There must be atleast some parameter require to start.
Such as :
Database Name
Control File Location
Whether Rollback Segmnet or Undo Management
Background/User/Core Dump Location etc..

Password File:
Password file is required to connect database remotely from one serever to another server.

Program Global Area (PGA)
When single-threaded servers are used, the Program Global Area (PGA) contains data (such as user’s session variables and arrays) for use only by a single process. Its contents is not visible to other processes (unless Oracle multithreaded server (MTS) is used).

System Global Area (SGA)

The Shared System Global Area (SGA) contains user data and control information for a single Oracle Instance. Its contents is visible/accessible to several user applications and system processes.

Shared SQL Pool
When an SQL statement is issued by a user process, it goes through a parse tree in the shared pool.
The shared pool contains the library cache, data dictionary cache, execution plan and parse tree for SQL statements. contains library cache performance information for each type of object in the library cache.

Data Dictionary Cache

This area saves the re-reading of data from the Dictionary Table on a hard disk referenced while parsing SQL statements. It contains information such as segment information, security and access privileges, and available free storage space. It contains information such as user account data, datafile names, segment names, extent locations, table descriptions, and Privileges.

Library Cache

The Library Cache contains both shared and private SQL areas. The v$librarycache view lists performance information for each type of object in the library cache.
A private SQL area is created for each transaction initiated. It contains session-specific information, such as bind variables, environment and session parameters, runtime stacks and buffers, and so on. Each private area is deallocated after the cursor to the session is closed. The number of private SQL areas a user session can have open at one time is limited by the value of the OPEN_CURSORS init.ora parameter.
Within the private SQL area of the library cache, the persistent area contains information that is valid and applicable through multiple executions of the SQL statement. The runtime area contains data that is used only while the SQL statement is being executed.
To improver Oracle performance, Oracle uses a Shared SQL area to save in cache the intermediate results from SQL commands previously returned. So before performing a hard disk operation, Oracle can service identical requests simply by retrieving them from its cached memory for reuse. Specifically, the shared area contains the parse tree and execution path for SQL statements. It also contains headers of PL/SQL packages and procedures that have been executed.
Database Buffer Cache

The data block buffer stores the most recently queried data from the database. This is done for efficiency -- to avoid time-consuming hard disk operations. Its size is controlled by the variable DB_BLOCK_BUFFERS parameter, which has a value calculated from the size of about 1 to 2 percent of the database. This space is managed by latching and writing the Least Recently Used (LRU) block to hard disk.

The v$sqlarea view displays the text of SQL statements in the shared SQL area, plus the number of users accessing the statements, disk blocks and memory blocks accessed while executing the statement, and other information.
Redo Log Buffer Cache
The redo log buffer is used to store redo information in memory before it is flushed to the Online Redo Log Files. Its size is initialized according to the LOG_BUFFER (bytes) parameter. The number of redo log space requests can be monitored using the v$sysstat view.

Large Pool
Introduced with Oracle 8 to store user session global area infor and for parallel processing/recovery.


System Background Processes
The PROCESSES parameter in init.ora specifies the maximum number of processes accessing the database. The v$process view displays all processes that are connected to the database, including background and user processes.
The V$bgprocess view lists all background processes.

User and Server Processes (Snnn)
Applications and utilities access the RDBMS through a user process. The user process connects to a server process, which can be dedicated to one user process or shared by many user processes. The server process parses and executes SQL statements that are submitted to it and returns the result sets back to the user process. It is also the process that reads data blocks from the data files into the database buffer cache.
Four background processes are mandatory -- required for startup of each Oracle instance:
1. System Monitor (SMON)
The System monitor performs automatic crash recovery on the Oracle instance in the event it fails. If the command shutdown abort is issued by the user, Oracle doesn't have time to write modified database changes from the System Global Area (SGA) down to disk. It wakes itself up routinely to clean up free space in datafiles (much like a defragmenter for hard drives). It looks for free spaces and organizes them into contiguous areas.
2. Process Monitor (PMON)
The Process monitor performs recovery (such as releasing locks failed processes held on resources). PMON analyzes user processes that access the database, performs "garbage collection", and restarts failed processes in the database. It releases locks held by processes which failed before they released memory allocations.
3. Database Writer (DBWn)
The Database Writer (DBWR) writes and retrieves blocks from datafiles through the buffer cache. Some suggest using the DB_WRITERS parameter to define as many DBWR processes as there are physical disks used to store data files.
4. Log Writer (LGWR)
The Log Writer writes and retrieves its blocks from datafiles through the Redo Log Buffer.
5. Checkpoint Process (CKPT)
The checkpoint (CKPT) process frees up limited memory space and ensures instance recovery. It is a background process that monitors the number of dirty buffers that have not been written to disk. Depending on the LOG_CHECKPOINT_INTERVAL parameter, it also gives the DBWR a wakeup call to write dirty buffer to disk. At a specified time, it updates all the data and control files with the new log file control number. This process is optionally enabled if parameter CHECKPOINT_PROCESS contains a TRUE value.
Other background system processes ...
Redo log files are achived to tape or other media by the ARCH background process. In Oracle 8i, the DBWR_IO_SLAVES parameter defines the number of I/O slaves to improve performance. The v$archive view provides information on the archived logs written by ARCn (ARCH pre Oracle8i).
Alert Logs
Database start-ups and other commands and responses to commands to a database are stored in an Alert Log.

Trace Writer (TRWR)
The operating system Process ID for each running process are maintained in a trace file located in the file name specified in parameter BACKGROUND_DUMP_DEST. By default, that's folder /admin/INSTANCE_NAME/bdump under the ORACLE_BASE folder.
User trace Database trace start-up and other commands and responses to commands to a database are stored in an Alert Log.
Archival Process (ARCn)
The full online redo logs are copied to the archived redo log files by this process. If the database is operating in archivelog mode AND the ARCHIVE_LOG_START parameter in the init.ora file is not set to TRUE, the database will hang.

Some advance features in Oracle 9i

MATERIALIZED VIEW

A materialized view is a database object that contains the results of a query. The FROM clause
of the query can name tables, views, and other materialized views. Collectively these objects
are called master tables (a replication term) or detail tables (a data warehousing term).
This reference uses "master tables" for consistency. The databases containing the master
tables are called the master databases


CREATE MATERIALIZED VIEW sales_mv
REFRESH FAST ON COMMIT
AS SELECT t.calendar_year, p.prod_id,
SUM(s.amount_sold) AS sum_sales
FROM times t, products p, sales s
WHERE t.time_id = s.time_id AND p.prod_id = s.prod_id
GROUP BY t.calendar_year, p.prod_id;

FLASHBACK TABLE
Purpose

Use the FLASHBACK TABLE statement to restore an earlier state of a table in the event of human or application error. The time in the past to which the table can be flashed back is dependent on the amount of undo data in the system. Also, Oracle Database cannot restore a table to an earlier state across any DDL operations that change the structure of the table.


Oracle Utilities

Export
• A backup utility provided by Oracle
• Writes data from an Oracle database into Oracle binary-format files
• Exported data can only be read by the “Import” utility
• A User must have connect or DBA privilege to export table
• Exprt Modes:
o Table: The names of the tables to be exported need to be specified
o User: All objects belonging to the user are exported
o Database: All database objects are exported
• The command used is : exp

Table(s) Level Export
C:\> exp username/passward file=filename.dmp log=filename.log Tables=tablename,tablename

User Level Export
C:\> exp system/manager file=filename.dmp log=filename.log owner=username

Entire Database Level
C:\> exp system/manager file=filename.dmp log=filename.log full=y

Import
• Is used for importing data exported using the exp command into the Oracle database

Importing tables
C:\> Imp username/passward file=filename.dmp log=filename.log Tables=(tablename,tablename)

Importing User
C:\> Imp system/manager file=filename.dmp log=filename.log fromuser = username touser=username

Sql Loader

• This tool is used to move data from a Non-Oracle standard source into the Oracle Database
• Load data into multiple datafiles

by Sql Loader - sqlldr
step -1
- create a table
ex
create table person
(code number(2),
name varchar2(10));
setp - 2
- create a data file
ex
test.txt
10 MILLER
20 FORD
step - 3
- create a control file
load data
ex - ctrl.txt
infile
into table person
(code position (01:03) char,
name postion ( 04:10) char)
step - 4
c:\> sqlldr userid=sss/sss control=c:\ctrl.txt


To create multiple table in a SINGLE SQL Query

Create schema authorization sss
Create table a (a number)
Create table b (a number);

Where SSS is the User Name

Implementing Object Techniques

Object Technology:
• Object Technology is another step forward in the software enginnering life cycle that allows us to:
- Model real Thing
- Represent real thing as objects
• Object Technology is a method of managing complexity so that we can develop solutions that simulate real-world problems.
• Minimizing cost through reusibility

Oracle provides full support for all three different implementation – Relational, Object- Relational, Object- Oriented Relational.

Why Should Objects Be Used?

Objects reduce complexity by giving an intuitive way of representing complex data and its relations.

Besides simplifying the interaction with data, objects may help in other ways. Examples of benefits that come from using OO features are:

Object reuse: - If OO code is written; the chance of reusing previously written code modules is increased. Similarly, if OO database objects are created the chances that these database objects will be reused in increased.

Standard adherence:- If database objects are built using standards, then the chances they will be used increase exponentially. If multiple applications or tables use the same set of database objects, then a de facto standard for application of tables is being created.

OBJECT TYPES

Oracle supports many different types of objects. In the following sections, major object types are described.

Abstract Data type

Abstract Data type is a datatype that consists of one or more subtypes. Rather that being constrained to the standard Oracle data type of NUMBER, DATE, and VARCHAR2, the abstract data type can more accurately describe data.

Creation of an Object

CREATE TYPE address_ty AS OBJECT
(Street varchar2(50), city varchar2(25), state vachar2(25), zip number) ;

CREATE TYPE person_ty AS OBJECT
(name vachar2(250), address address_ty) ;

An abstract data type can be used to create an Object Table. In an object table, the columns of the table map to the columns of an abstract datatype.

CREATE TYPE address_ty AS OBJECT
(Street varchar2(50), city varchar2(25), state varchar2(25), zip number) ;

CREATE TYPE person_ty AS OBJECT
(name vachar2(250), address address_ty) ;

CREATE TABLE customer
(customer_id number, person person_ty)

Retrieving Data using Objects

SELECT client.Person.Name Client.Person.Address.City FROM customer client
WHERE client.person.address.city like ‘M%’ ;

Updating Data using Objects

UPDATE customer client
SET client.person.addess.city=’Mumbai’ where Client.Person.Address.City=’Chennai’ ;

Deleting Data using Objects

DELETE from customer client where client.person.addess.city=’Mumbai’ ;

Nested Tables

A nested table is a table within a table. A nested is a collection of rows, represented as a column within the main table. For each record within the main table, the nested table as a column. In one sense, it’s a way of storing a one-to-many relationship within one table.

Varying Arrays

A varying array is a set if objects, each with the same data type. The size of the array is limited when it is created.

When a table is created with a varying array, the array is a nested table a limited set of rows

Varying Arrays, also known as VARRAYS, allows storing repeating attributes in tables.

References

Nested tables and Varying Arrays are embedded objects. They are physically embedded within another object. Another type of object, called referenced objects, are Physically separated from the objects that refer to them. References (also known as REFs) are essentially pointers to row objects. A row object is different from a column object. An example of a column object would be a varying array, it is an object that is treated as a column in a table. A row object, on the other hand, always represents a row.

References are typically among the last OO features implemented when migrating a relational database to an object-relational or pure OO one.

Object views

Object views allow adding OO concepts on top of existing relational tables. For example, an abstract data type can be created based on an existing table definition. Thus, object views give the benefits of relational table storage and OO structures. Object views allow the development of OO features within a relational database, a kind of bridge between the relational and OO worlds.

CREATE TYPE address_ty AS OBJECT
(Street varchar2(50), city varchar2(25), state varchar2(25), zip number) ;

CREATE TYPE person_ty AS OBJECT
(name varchar2(25), address address_ty) ;

CREATE TABLE customer
(customer_id number, person person_ty) ;


create view cust_obj of address_ty with object oid
(customer_id) as
select customer_id,person_ty(name,address_ty(Street,city,state,zip)) from customer ;


VARIABLE ARRAYS

A varying array allows the storing of repeated attributes of a record in a single row. Varying arrays are collectors that allow repetition of only those column values that change, potentially saving storage space. Varying arrays can be used to accurately represent one –to –many relationships where the maximum number of elements on the many side of the relationship is known and where the order of these elements is important.

CREATE TYPE COMPANY_ADDRESS_TY AS VARRAY (3) OF varchar2 (1000);

This statement creates a varray type called company_address_typ, which can hold a maximum of 3 elements of data type varchar2(1000), i.e. 3 entries per record, each storing address information for the company.
Now that the varying array company_address_ty is created, this can be used as a part of the creation of either a table or an abstract datatype

Create table company_info
(company_name varchar2(50), address company_address_ty);
this SQL statement creates a table called company_info, which contains an embedded object called address that is a varray of type company_address_ty.

ORCLE stores the varying array data internally using the RAW datatype.

Reference object

The referencing object (REFs data type) is something that is new to ORACLE 8i. This data type acts as a pointer to an object. A REF can also be used in a manner similar to a foreign key in a RDBMS. A REF is used primarily to store an object identifier, and to allow the user to select that object.

REF’s establish relationship between two-object tables, much the same way as a primary-key/foreign-key relationship in relational tables. Relational tables however, have difficulty, if more than one table is needed in a primary-key/foreign-key relationship related to a single table. For example, an address table, that stores addresses from several entities. The use of REFs eliminates this problem, because an unscoped REF can refer to any accessible object table.

A scope clause in a definition forces a set of REFs for a given column to be confined to a single object table. There can be only one REF clause for a given REF column. REF scope can be set at either the column or table level.

REF values can be stored with or without a ROWID. Storing a REF with a ROWID seeds de-referencing operation, but takes more space. If with ROWID is not specified with the REF clause, the default is to not store ROWIDs with the REF values. SCOPE clauses prevent dangling references, as they will not allow REF values unless the corresponding entries in the SCOPE table is present.

REF columns can be added to nested tables with the ALTER TABLE command.

A call to a REF returns the OID of the object instance. An OID is a 128 bytes base –64 number, which is not very useful except as handle to the object instance. To get the value stored in the instance that is referred to by a REF, the DEREF routine is used. DEREF returns values in the object instance referenced by a specific REF value.

New SQL function in Oracle 9i

COALESCE

You can also use COALESCE as a variety of the CASE expression. For example,
COALESCE (expr1, expr2)

is equivalent to:

CASE WHEN IS expr1 NOT NULL THEN expr1 ELSE expr2 END

Similarly,

COALESCE (expr1, expr2, ..., exprn), for n>=3

is equivalent to:

CASE WHEN expr1 IS NOT NULL THEN expr1
ELSE COALESCE (expr2, ..., exprn) END

select comm,COALESCE(0.9*comm, comm,5) from emp ;


CURRENT_DATE

Purpose

CURRENT_DATE returns the current date in the session time zone, in a value in the Gregorian
calendar of datatype DATE.


Examples

The following example illustrates that CURRENT_DATE is sensitive to the session time zone:

ALTER SESSION SET TIME_ZONE = '-5:0';
ALTER SESSION SET NLS_DATE_FORMAT = 'DD-MON-YYYY HH24:MI:SS';
SELECT SESSIONTIMEZONE, CURRENT_DATE FROM DUAL;

SESSIONTIMEZONE CURRENT_DATE
--------------- --------------------
-05:00 29-MAY-2000 13:14:03

ALTER SESSION SET TIME_ZONE = '-8:0';
SELECT SESSIONTIMEZONE, CURRENT_DATE FROM DUAL;

SESSIONTIMEZONE CURRENT_DATE
--------------- --------------------
-08:00 29-MAY-2000 10:14:33


CURRENT_TIMESTAMP


Purpose

CURRENT_TIMESTAMP returns the current date and time in the session time zone, in a value of
datatype TIMESTAMP WITH TIME ZONE. The time zone offset reflects the current local time of
the SQL session. If you omit precision, then the default is 6. The difference between this function and LOCALTIMESTAMP is that CURRENT_TIMESTAMP returns a TIMESTAMP WITH TIME ZONE value while LOCALTIMESTAMP returns a TIMESTAMP value.

In the optional argument, precision specifies the fractional second precision of the time value
returned.

Examples

The following example illustrates that CURRENT_TIMESTAMP is sensitive to the session time zone:

ALTER SESSION SET TIME_ZONE = '-5:0';
ALTER SESSION SET NLS_DATE_FORMAT = 'DD-MON-YYYY HH24:MI:SS';
SELECT SESSIONTIMEZONE, CURRENT_TIMESTAMP FROM DUAL;

SESSIONTIMEZONE CURRENT_TIMESTAMP
--------------- ---------------------------------------------------
-05:00 04-APR-00 01.17.56.917550 PM -05:00

ALTER SESSION SET TIME_ZONE = '-8:0';
SELECT SESSIONTIMEZONE, CURRENT_TIMESTAMP FROM DUAL;

SESSIONTIMEZONE CURRENT_TIMESTAMP
--------------- ----------------------------------------------------
-08:00 04-APR-00 10.18.21.366065 AM -08:00

If you use the CURRENT_TIMESTAMP with a format mask, take care that the format mask matches the
value returned by the function. For example, consider the following table:

CREATE TABLE current_test (col1 TIMESTAMP WITH TIME ZONE);

The following statement fails because the mask does not include the TIME ZONE portion of the
type returned by the function:

INSERT INTO current_test VALUES
(TO_TIMESTAMP_TZ(CURRENT_TIMESTAMP, 'DD-MON-RR HH.MI.SSXFF PM'));

The following statement uses the correct format mask to match the return type of
CURRENT_TIMESTAMP:

INSERT INTO current_test VALUES (TO_TIMESTAMP_TZ
(CURRENT_TIMESTAMP, 'DD-MON-RR HH.MI.SSXFF PM TZH:TZM'));

EXTRACT (DATETIME)

Purpose

EXTRACT extracts and returns the value of a specified datetime field from a datetime or interval value expression. When you extract a TIMEZONE_REGION or TIMEZONE_ABBR (abbreviation), the value returned is a string containing the appropriate time zone name or abbreviation. When you extract any of the other values, the value returned is in the Gregorian calendar. When extracting from a datetime with a time zone value, the value returned is in UTC. For a listing of time zone names and their corresponding abbreviations, query the V$TIMEZONE_NAMES dynamic performance view.

SELECT EXTRACT(YEAR FROM DATE '1998-03-07') FROM DUAL;

EXTRACT(YEARFROMDATE'1998-03-07')
---------------------------------
1998

The following example selects from the sample table hr.employees all employees who were hired
after 1998:

SELECT ename, empno, hiredate FROM emp WHERE EXTRACT(YEAR FROM TO_DATE(hiredate, 'DD-MON-RR')) <>
ORDER BY hiredate;

ENAME EMPNO HIREDATE
---------- ---------- ---------
suresh 2345 02-JAN-76
SMITH 7369 17-DEC-80
ALLEN 7499 20-FEB-81
WARD 7521 22-FEB-81

FIRST

Purpose

FIRST and LAST are very similar functions. Both are aggregate and analytic functions that
operate on a set of values from a set of rows that rank as the FIRST or LAST with respect
to a given sorting specification. If only one row ranks as FIRST or LAST, the aggregate
operates on the set with only one element.

This function takes as an argument any numeric datatype or any nonnumeric datatype that can
be implicitly converted to a numeric datatype. The function returns the same datatype as the
numeric datatype of the argument.

When you need a value from the first or last row of a sorted group, but the needed value is
not the sort key, the FIRST and LAST functions eliminate the need for self joins or views
and enable better performance.


select deptno,
min(sal) KEEP (DENSE_RANK FIRST ORDER BY comm) "Worst",
MAX(sal) KEEP (DENSE_RANK LAST ORDER BY comm) "Best"
from emp
group by deptno ;


DEPTNO Worst Best
---------- ---------- ----------
10 1300 5000
20 800 3000
30 1500 2850
40 3456 3456
60 2345 2345
90 5657 5657

NULLIF

Purpose

NULLIF compares expr1 and expr2. If they are equal, then the function returns null. If they
are not equal, then the function returns expr1. You cannot specify the literal NULL for expr1.
If both arguments are numeric datatypes, then Oracle Database determines the argument with
the higher numeric precedence, implicitly converts the other argument to that datatype,
and returns that datatype. If the arguments are not numeric, then they must be of the same
datatype, or Oracle returns an error.

The NULLIF function is logically equivalent to the following CASE expression:
CASE WHEN expr1 = expr 2 THEN NULL ELSE expr1 END


Examples

The following example selects those employees from the sample schema hr who have changed jobs
since they were hired, as indicated by a job_id in the job_history table different from the
current job_id in the employees table:

SELECT e.ename, NULLIF(e.job, j.job) "Old Job"
FROM emp e, job_history j
WHERE e.empno = j.empno
ORDER BY ename;

ENAME Old Job I
---------- ---------
ADAMS
ALLEN
BLAKE
CLARK
FORD
ggggg
suresh Program

Oracle Supplied Packages

Oracle Supplied Packages

Oracle Supplied Package

- Are provided with the Oracle Server
- Extend the functionality of the database
- Enables access to certain SQL features normally restricted for PL/SQL.

Using Native Dynamic SQL
- Is a SQL statement that contains variables that can change during runtime
- Is a SQL staement with placeholders abd is stored as a character string.
- Enables general-purpose code to be written
- Enables data-defination, data_control or session-control statements to be written and executed from PL/SQL.
- Is written using either DBMS_SQL or native dynamic SQL.

Using the DBMS_SQL Package

The DBMS_SQL package is used to write dynamic SQL in stored procedures and to parse DDL statements. Some of the procedures and functions of the package includes:

- OPEN_CURSOR
- PARSE
- BIND_VARIABLE
- EXECUTE
- FETCH_ROWS
- CLOSE_CURSOR

Componets of the DBMS_SQL Package

Function or Porcedure

Description

OPEN_CURSOR

Opnes a new cursor and assigns a cursor ID number

PARSE

Parses the DDL or DML ststements: that is, checks the statements’s syntax and associates it with the opned cursor (DDL statement are immediately executed when parsed)

BIND_VARIABLE

Binds the given value to the variable identified by its name in the parsed statement in the given cursor

EXECUTE

Executes the SQL statement and returns the number of rows processed

FETCH_ROWS

Retrives a row for the specified cursor (for multiple rows, call in a loop)

CLOSE_CURSOR

Closes the specified cursor



create or replace procedure delete_all_rows
(p_tab_name in varchar2, p_rows_del out number)
is
cursor_name integer;
begin
cursor_name := DBMS_SQL.open_cursor ;
DBMS_SQL.PARSE(cursor_name,'DELETE From '||P_tab_name,dbms_sql.native) ;
p_rows_del := DBMS_sql.EXECUTE(cursor_name) ;
DBMS_SQL.close_cursor(cursor_name) ;
end;

Dynamic SQL Using EXECUTE IMMEDIATE

Create procedure del_rows
(p_table_name in varchar2,
p_rows_deld out number)
IS
Begin
Execute immediate ‘delete from ‘||p_table_name ;
P_rows_deld := SQL%ROWCOUNT ;
End ;

SQL> variable a number
SQL> execute del_rows ('EMP1', :a)

SQL> print a

Using DBMS_JOB for Scheduling

DBMS_JOB enables the scheduling and execution of PL/SQL programs:

- Submitting jobs
- Executing jobs
- Changing execution parameters of jobs
- Remove jobs
- Suspending Jobs