Home
Search results “Oracle temporary table in memory”
Oracle 18c - Private temporary tables
 
01:57
New to 18c! Private temporary tables. blog: https://connor-mcdonald.com Not only is your data private to your session, but so is the definition of the table itself.
Views: 1344 Connor McDonald
Oracle 18C New Feature Private Temporary Table
 
12:01
What is oracle private temporary table? This video explains about the global temporary table, and private temporary table concepts. A typo error in the slide, Please read "ON COMMIT DROP DEFINITION" instead of "ON COMMIT DELETE DEFINITION"
Views: 80 Siva Academy
Session-Private Statistics for Global Temporary Tables (GTTs) in Oracle 12c
 
02:18
This video the session-private statistics functionality for Global Temporary Tables (GTTs) in Oracle 12c. For more information see: https://oracle-base.com/articles/12c/session-private-statistics-for-global-temporary-tables-12cr1 Website: https://oracle-base.com Blog: https://oracle-base.com/blog Twitter: https://twitter.com/oraclebase Cameo by Enrique Aviles Twitter: https://twitter.com/eaviles94 Cameo appearances are for fun, not an endorsement of the content of this video.
Views: 671 ORACLE-BASE.com
Benefits of Common Table Expressions
 
05:56
On this episode of Joes 2 Pros SQL server unlocked series we present a topic for anyone who has ever been exposed to SQL Server, Common Table Expressions. A CTE is memory resident table. You are pulling from that query and giving it a name. This table adds enhancements to the old tables. It allows you to open up to new people without having an increased security risk. This is extremely beneficial for anyone who is exposed to SQL Server as keeping your content safe is a top concern for most organizations. In this video, he will take you through a very real example from a department store quarterly reporting. He wants to do a seasonal reporting from all the departments of a store excluding snow sports and cooking. He shows you how to make the code more simple and reduce human error. Having CTE knowledge will be greatly beneficial to you in your everyday career. Please be sure to follow along our blog series. Stay tuned next week to learn more about Dynamic SQL. To learn more about he benefits of common table expressions view our course Developer 2012 Volume 2 Video 10.1. See more at: http://www.joes2pros.com/joes2pros/courses Full Blog: http://joes2prosblog.social27.com/
Heap Tables and Index Organized Tables in Oracle | Chris Saxon
 
02:55
Chris Saxon, a database evangelist, developer advocate, and SQL specialist with Oracle, uses up his two minutes with a tip on using heap tables and index organized tables in Oracle Database.
SQL Server - Temp Tables Vs Table Variables
 
28:31
We provide online Training and Classroom Training on MSBI, SQL Server, Hadoop, .NET, Java, Oracle, Tableau etc. Contact: [email protected] Ph No: +91 9000075637
Views: 4657 Bhaskar Jogi
Crash Recovery in Oracle RAC - DBArch Video 16
 
06:37
In this video you will understand how an Oracle RAC cluster recovers from an Instance Crash which is also called Crash Recovery. The video will use the whiteboard to show you what happens when one of the nodes crashes in a Cluster and how the surviving node recovers the failed node related transactions.
Views: 6991 Ramkumar Swaminathan
SCPT 46:Oracle Storage Termininology:  High Water Mark and Free Lists
 
15:31
Oracle DBA Tutorials For Full Course Experience Please Go To http://mentorsnet.org/course_preview?course_id=6 Full Course Experience Includes 1. Access to course videos and exercises 2. View & manage your progress/pace 3. In-class projects and code reviews 4. Personal guidance from your Mentors
Views: 17357 Oresoft LWC
Heap tables
 
21:48
Views: 1108 Nikolay Savvinov
Table size ,Number of records,Disk usage in SQL Database,clear logs,cache
 
06:51
This clip will show you how to check each Table size, Number of records, Disk usage in SQL Database. You can see how to write the query to get details of all tables in terms of size, records, space utilization and free space on disk for tables. http://daynamicsaxaptatutorials.blogspot.com This is axapta ERP blog for Technical and functional fields and includes Microsoft Dynamics Axapta tutorials and Dynamics Axapta Coverage. This blog also contains x++ code help for Ax developer and solution of technical and functional daily issues. This blog is specific for Microsoft dynamics programming. Enterprise portal, SharePoint services, business connectors and Enterprise Resource Planning applications and sql database.It will help to get Microsoft Business Solutions.
Views: 515 Santosh kumar Singh
12c Adaptive Optimization - Kerry Osborne
 
01:08:29
One of the most interesting new features of the Oracle Database Optimizer is the ability to recognize its own mistakes and use execution statistics to automatically improve execution plans. Oracle calls this "Adaptive Optimization" and this talk will focus on how it works. More webinars at: http://www.red-gate.com/oracle-webinars
Views: 6575 Redgate Videos
Relationships of Physical and Logical Storage structures in an Oracle Database - DBArch Video 22
 
06:14
In this video you will understand the Relationships between the Physical files and Logical Components - Tablespace, Segments, Extents and Oracle Blocks in an Oracle Database
Views: 7105 Ramkumar Swaminathan
IO6: Querying Files with the External Table Feature
 
11:36
The external table feature of Oracle Database allows you apply SQL SELECT operations to the contents of files. Download my demo.zip from v.gd/sfdemo to access and run all referenced scripts. This video was taken from PLSQLChannel.com, originally recorded before Steven Feuerstein re-joined Oracle in March 2014. ======================================== Practically Perfect PL/SQL with Steven Feuerstein Copyright © 2015 Oracle and/or its affiliates. Oracle is a registered trademark of Oracle and/or its affiliates. All rights reserved. Other names may be registered trademarks of their respective owners. Oracle disclaims any warranties or representations as to the accuracy or completeness of this recording, demonstration, and/or written materials (the “Materials”). The Materials are provided “as is” without any warranty of any kind, either express or implied, including without limitation warranties or merchantability, fitness for a particular purpose, and non-infringement.
Multi-User Concurrent Transactions in an Oracle Database - DBArch  Video 12
 
03:51
This video explains how an Oracle Database manages multi-user concurrent transactions. A database a multi-user environment and this video tells you how redo and data files are managed by an Oracle Instance / Database.
Views: 3923 Ramkumar Swaminathan
Oracle Performance Tuning online Training and Support
 
03:51
Feel free to contact Call : +91-8870903864 Or E-mail [email protected] ORACLE PERFORMANCE TUNING 1 – 1: Introduction to Oracle tuning - The top-down approach to tuning - The history of Oracle tuning - A review of the Oracle architecture - The goals of Oracle tuning - Overview of SQL tuning - Oracle network bottlenecks 1 – 2: Oracle disk I/O tuning - History of DASD - Understanding disk I/O - Monitoring disk I/O (AWR, dba_hist_filestatxs) - Sorted hash cluster tables - Disk I/O waits - Oracle data buffer internals (db_cache_size) - Caching data blocks in the PGA (parallel full-table scans) - Blocksize and I/O performance 1 – 3: Oracle CPU Tuning - Finding your cpu_count - Measuring CPU usage with vmstat - _optimizer_cost_model=cpu - Parallel query and CPU 1 – 4: Oracle RAM tuning - all_rows and first_rows optimization and RAM - Multiple data buffers - Multiple blocksizes - Measuring RAM paging - Oracle SGA RAM - Oracle PGA RAM - Using the KEEP pool - Automatic Memory Management (AMM) 1 – 5: Oracle Instance Tuning - Global tuning techniques - Display possible unnecessary large-table full-table scans - Library cache tuning 1 – 6: Oracle SQL Tuning Introduction - SQL tuning hierarchy - SQL tuning goals - optimizer modes - query re-write - cursor_sharing - viewing execution plans (autotrace) - verifying optimal join techniques - parallelizing SQL execution - dynamic statistics - Exercise – count times when a table is invoked - 12c new SQL features - function-based virtual column - adaptive execution plans - 12c new optimizer metadata collection features 2 – 1: AWR and ASH - AWR vs STATSPACK - Reading an AWR report - AWR report analyzer - Basics of predictive modeling for performance - Finding repeating signatures of data 2 - 2: Oracle RAC Tuning - RAC architecture tuning - Tuning disk I/O on RAC - Tuning the cache fusion layer on RAC 2 – 3: Oracle Tuning Pack - creating SQL Profiles - Recommending new indexes - “automatic” SQL Tuning - SQL Performance Advisor (SPA) - recommending object reorganization 2 – 5: Oracle Diagnostic pack - AWR and ASH - real time SQL monitoring - comparing performance periods - Oracle monitoring & alert notifications (setting thresholds) 2 – 6: Oracle Tracing - 10046 tracing - TKPROF tracing - Trace analyzer - Autotrace 3 –2: Optimizing Oracle SQL - Parsing a SQL statement - Semantic parsing 3 –3: Optimizer statistics - Types of metadata - System stats 3 – 4: Exposing & Reading Execution Plans - autotrace - SQL*Trace - Determine the steps of an execution plan 3 – 5: altering execution plans - Changing CBO statistics - Using hints - Using the opt_param hint 3 – 6: Oracle indexing - Overview of Oracle indexing - function-based indexes (FBI) - index usage monitoring - fishing in the library cache - optimizing indexes - Identifying EOW, EOM and EOY SQL. - Creating on-demand indexing - oracle text indexes DAY 4 Advanced Topics in Tuning 4 – 1: Boolean/Built-in functions - Boolean evaluation - Decode and case - Basics of B PGA to avoid disk sortsIFs - Function-based indexing - Creating a custom BIF using PL/SQL - The effect of BIFs on SQL execution 4 – 2: tuning Oracle sorting - Basics of sorting - RAM usage in a hash join - Use autotrace to see sorts 4 – 3: Tuning Oracle subqueries - Scalar subqueries - In-Line views - Correlated vs non-correlated subqueries - The merge_aj hint - The anti-join hints 4 – 4 Tuning with temp objects (materialized views, global temporary tables) - Tuning with temporary tables 4- 5: Tuning full-table scans - Basics of file multiblock I/O - Deciding when to invoke full-table scan - RAM caching in the SGA - Tracking full-scans over time with AWR 4- 6 tuning parallel query - Parallel query Oracle Performance Tuning training online, Oracle Performance Tuning training material, IBM Websphere Application Server training cost, Oracle Performance Tunning training pdf, Websphere Application Server training in USA uae India, Oracle Performance Tuning training, online Corporate training malaysia Singapore, Oracle Performance Tuning software, Oracle Performance Tuning training in bangalore, Oracle Performance Tuning training institutes in hyderabad, Oracle Performance Tuning training in chennai, Oracle Performance Tuning training in hyderabad, Delhi, Mumbai, Pune, Oracle Performance Tunning, Oracle Performance Tuning training webinar, online training singapore, Oracle Performance Tuning eam, Oracle Performance Tuning as a service,Oracle Performance Tuning online Training Oracle Performance Tuning online Training Oracle Performance Tuning online Training Oracle Performance Tunning online Training maximo scheduler, Oracle Performance Tunning (consumer product) Oracle Performance Tunning online Training Oracle Performance Tuning online Training Oracle Performance Tuning online Training Oracle Performance Tuning online Training Oracle Performance Tuning online Training , Post Training Support
Views: 45 Trainers Online
SELECT statement Processing in an Oracle Database - DBArch  Video 7
 
06:22
You will learn from this video how a SELECT statement is processed in an Oracle Database. You will learn about the a Parse, Execute and Fetch phases in a select statement.
Views: 13252 Ramkumar Swaminathan
Structure of a Row - DBArch Video 30
 
03:53
In this video you will learn how a Row is structured. You will learn about its header and column data sections.
Views: 1377 Ramkumar Swaminathan
Why Isn't My Query Using an Index?
 
47:01
“Why isn’t my query using an index?” is a common question people have when tuning SQL. This session explores the factors that influence the optimizer’s decision to answer this question. It does so by comparing fetching rows from a database table to finding all the red M&Ms a packet, and contrasts using an index range scan and a full table scan. It also introduces the concepts of blocks and the clustering factor. The session offers a discussion of how these affect the optimizer's calculations, and includes a demo of how these concepts work in practice using real SQL queries. This session is intended for developers who want to learn the basics of how the optimizer chooses between an index range or full table scan. Speaker: Chris Saxon
Views: 226 Oracle Developers
Oracle Database and Instance Components - DBArch Video 3
 
10:09
In this video you will learn about the Relationship between and Oracle Instance and an Oracle Database. You will know about the various components of an Instance ( SGA and Background Processes) and the various files of the Database and how they interact.
Views: 15086 Ramkumar Swaminathan
In-Memory OLTP Memory Optimized Table Variables Vs Disk Based Table Variable in SQL Server
 
12:59
Refer to http://www.sqlvideo.com/AllVideos/Memory-Optimized-Table-Variables-Vs-Disk-Based-Table-Variable for additional details. This SQL Server Video includes demos. You have the possibility to practice the hands-on examples while watching the video. SQLTest Tool (http://www.sqltest.org) simulates the hands-on labs for you, no registration necessary.
Views: 3218 SQLWorkshops
SQL: WITH Clause
 
06:11
In this tutorial, you'll learn will learn how to use with clause PL/SQL (Procedural Language/Structured Query Language) is Oracle Corporation's procedural extension for SQL and the Oracle relational database. PL/SQL is available in Oracle Database (since version 7), TimesTen in-memory database (since version 11.2.1), and IBM DB2 (since version 9.7).[1] Oracle Corporation usually extends PL/SQL functionality with each successive release of the Oracle Database. PL/SQL includes procedural language elements such as conditions and loops. It allows declaration of constants and variables, procedures and functions, types and variables of those types, and triggers. It can handle exceptions (runtime errors). Arrays are supported involving the use of PL/SQL collections. Implementations from version 8 of Oracle Database onwards have included features associated with object-orientation. One can create PL/SQL units such as procedures, functions, packages, types, and triggers, which are stored in the database for reuse by applications that use any of the Oracle Database programmatic interfaces. PL/SQL works analogously to the embedded procedural languages associated with other relational databases. For example, Sybase ASE and Microsoft SQL Server have Transact-SQL, PostgreSQL has PL/pgSQL (which emulates PL/SQL to an extent), and IBM DB2 includes SQL Procedural Language,[2] which conforms to the ISO SQL’s SQL/PSM standard. The designers of PL/SQL modeled its syntax on that of Ada. Both Ada and PL/SQL have Pascal as a common ancestor, and so PL/SQL also resembles Pascal in several aspects. However, the structure of a PL/SQL package does not resemble the basic Object Pascal program structure as implemented by a Borland Delphi or Free Pascal unit. Programmers can define public and private global data-types, constants and static variables in a PL/SQL package.[3] PL/SQL also allows for the definition of classes and instantiating these as objects in PL/SQL code. This resembles usage in object-oriented programming languages like Object Pascal, C++ and Java. PL/SQL refers to a class as an "Abstract Data Type" (ADT) or "User Defined Type" (UDT), and defines it as an Oracle SQL data-type as opposed to a PL/SQL user-defined type, allowing its use in both the Oracle SQL Engine and the Oracle PL/SQL engine. The constructor and methods of an Abstract Data Type are written in PL/SQL. The resulting Abstract Data Type can operate as an object class in PL/SQL. Such objects can also persist as column values in Oracle database tables. PL/SQL is fundamentally distinct from Transact-SQL, despite superficial similarities. Porting code from one to the other usually involves non-trivial work, not only due to the differences in the feature sets of the two languages,[4] but also due to the very significant differences in the way Oracle and SQL Server deal with concurrency and locking. There are software tools available that claim to facilitate porting including Oracle Translation Scratch Editor,[5] CEITON MSSQL/Oracle Compiler [6] and SwisSQL.[7] The StepSqlite product is a PL/SQL compiler for the popular small database SQLite. PL/SQL Program Unit A PL/SQL program unit is one of the following: PL/SQL anonymous block, procedure, function, package specification, package body, trigger, type specification, type body, library. Program units are the PL/SQL source code that is compiled, developed and ultimately executed on the database. The basic unit of a PL/SQL source program is the block, which groups together related declarations and statements. A PL/SQL block is defined by the keywords DECLARE, BEGIN, EXCEPTION, and END. These keywords divide the block into a declarative part, an executable part, and an exception-handling part. The declaration section is optional and may be used to define and initialize constants and variables. If a variable is not initialized then it defaults to NULL value. The optional exception-handling part is used to handle run time errors. Only the executable part is required. A block can have a label. Package Packages are groups of conceptually linked functions, procedures, variables, PL/SQL table and record TYPE statements, constants, cursors etc. The use of packages promotes re-use of code. Packages are composed of the package specification and an optional package body. The specification is the interface to the application; it declares the types, variables, constants, exceptions, cursors, and subprograms available. The body fully defines cursors and subprograms, and so implements the specification. Two advantages of packages are: Modular approach, encapsulation/hiding of business logic, security, performance improvement, re-usability. They support object-oriented programming features like function overloading and encapsulation. Using package variables one can declare session level (scoped) variables, since variables declared in the package specification have a session scope.
Views: 9595 radhikaravikumar
39 Mysql Database Engine Memory
 
19:46
MySQL Edition Video Tutorials
Views: 398 saratutus
Oracle Database 18c - The new Release Model
 
03:48
Highlights from the May 2018 Office Hours "Ask Me Anything" session hosted by Gerald Venzl and Maria Colgan. Keep your knowledge and skills up to date with direct access to senior experts inside Oracle Corporation by subscribing to the AskTOM Office Hours session. They are held every week and are 100% free. Register at https://asktom.oracle.com. https://developer.oracle.com/ https://cloud.oracle.com/en_US/tryit music: kevin mcleoud (incomptech.com)
Views: 157 Oracle Developers
Oracle DBDEV: Great year for Database In-Memory  Maria Colgan - ODTUG 15
 
05:03
Oracle Database In-Memory has taken center stage as it drives greater performance for the realtime enterprise. Maria Colgan gives us an update on adoption, and the most compelling use cases.
Views: 209 Database Community
Instance Recovery in an Oracle Database - DBArch Video 10
 
06:00
This video explains how Instance recovery happens in an Oracle Database.
Views: 7186 Ramkumar Swaminathan
PL/SQL: Brief on Associative Arrays
 
10:52
In this tutorial, you'll learn the points to be noted on AA PL/SQL (Procedural Language/Structured Query Language) is Oracle Corporation's procedural extension for SQL and the Oracle relational database. PL/SQL is available in Oracle Database (since version 7), TimesTen in-memory database (since version 11.2.1), and IBM DB2 (since version 9.7).[1] Oracle Corporation usually extends PL/SQL functionality with each successive release of the Oracle Database. PL/SQL includes procedural language elements such as conditions and loops. It allows declaration of constants and variables, procedures and functions, types and variables of those types, and triggers. It can handle exceptions (runtime errors). Arrays are supported involving the use of PL/SQL collections. Implementations from version 8 of Oracle Database onwards have included features associated with object-orientation. One can create PL/SQL units such as procedures, functions, packages, types, and triggers, which are stored in the database for reuse by applications that use any of the Oracle Database programmatic interfaces. PL/SQL works analogously to the embedded procedural languages associated with other relational databases. For example, Sybase ASE and Microsoft SQL Server have Transact-SQL, PostgreSQL has PL/pgSQL (which emulates PL/SQL to an extent), and IBM DB2 includes SQL Procedural Language,[2] which conforms to the ISO SQL’s SQL/PSM standard. The designers of PL/SQL modeled its syntax on that of Ada. Both Ada and PL/SQL have Pascal as a common ancestor, and so PL/SQL also resembles Pascal in several aspects. However, the structure of a PL/SQL package does not resemble the basic Object Pascal program structure as implemented by a Borland Delphi or Free Pascal unit. Programmers can define public and private global data-types, constants and static variables in a PL/SQL package.[3] PL/SQL also allows for the definition of classes and instantiating these as objects in PL/SQL code. This resembles usage in object-oriented programming languages like Object Pascal, C++ and Java. PL/SQL refers to a class as an "Abstract Data Type" (ADT) or "User Defined Type" (UDT), and defines it as an Oracle SQL data-type as opposed to a PL/SQL user-defined type, allowing its use in both the Oracle SQL Engine and the Oracle PL/SQL engine. The constructor and methods of an Abstract Data Type are written in PL/SQL. The resulting Abstract Data Type can operate as an object class in PL/SQL. Such objects can also persist as column values in Oracle database tables. PL/SQL is fundamentally distinct from Transact-SQL, despite superficial similarities. Porting code from one to the other usually involves non-trivial work, not only due to the differences in the feature sets of the two languages,[4] but also due to the very significant differences in the way Oracle and SQL Server deal with concurrency and locking. There are software tools available that claim to facilitate porting including Oracle Translation Scratch Editor,[5] CEITON MSSQL/Oracle Compiler [6] and SwisSQL.[7] The StepSqlite product is a PL/SQL compiler for the popular small database SQLite. PL/SQL Program Unit A PL/SQL program unit is one of the following: PL/SQL anonymous block, procedure, function, package specification, package body, trigger, type specification, type body, library. Program units are the PL/SQL source code that is compiled, developed and ultimately executed on the database. The basic unit of a PL/SQL source program is the block, which groups together related declarations and statements. A PL/SQL block is defined by the keywords DECLARE, BEGIN, EXCEPTION, and END. These keywords divide the block into a declarative part, an executable part, and an exception-handling part. The declaration section is optional and may be used to define and initialize constants and variables. If a variable is not initialized then it defaults to NULL value. The optional exception-handling part is used to handle run time errors. Only the executable part is required. A block can have a label. Package Packages are groups of conceptually linked functions, procedures, variables, PL/SQL table and record TYPE statements, constants, cursors etc. The use of packages promotes re-use of code. Packages are composed of the package specification and an optional package body. The specification is the interface to the application; it declares the types, variables, constants, exceptions, cursors, and subprograms available. The body fully defines cursors and subprograms, and so implements the specification. Two advantages of packages are: Modular approach, encapsulation/hiding of business logic, security, performance improvement, re-usability. They support object-oriented programming features like function overloading and encapsulation. Using package variables one can declare session level (scoped) variables, since variables declared in the package specification have a session scope.
Views: 5804 radhikaravikumar
In Memory Table Structure
 
01:00:47
SQL Server 2014 In-Memory Table Structure
PL/SQL: Mutating Triggers Part-2
 
08:41
In this tutorial, you'll learn... PL/SQL (Procedural Language/Structured Query Language) is Oracle Corporation's procedural extension for SQL and the Oracle relational database. PL/SQL is available in Oracle Database (since version 7), TimesTen in-memory database (since version 11.2.1), and IBM DB2 (since version 9.7).[1] Oracle Corporation usually extends PL/SQL functionality with each successive release of the Oracle Database. PL/SQL includes procedural language elements such as conditions and loops. It allows declaration of constants and variables, procedures and functions, types and variables of those types, and triggers. It can handle exceptions (runtime errors). Arrays are supported involving the use of PL/SQL collections. Implementations from version 8 of Oracle Database onwards have included features associated with object-orientation. One can create PL/SQL units such as procedures, functions, packages, types, and triggers, which are stored in the database for reuse by applications that use any of the Oracle Database programmatic interfaces. PL/SQL works analogously to the embedded procedural languages associated with other relational databases. For example, Sybase ASE and Microsoft SQL Server have Transact-SQL, PostgreSQL has PL/pgSQL (which emulates PL/SQL to an extent), and IBM DB2 includes SQL Procedural Language,[2] which conforms to the ISO SQL’s SQL/PSM standard. The designers of PL/SQL modeled its syntax on that of Ada. Both Ada and PL/SQL have Pascal as a common ancestor, and so PL/SQL also resembles Pascal in several aspects. However, the structure of a PL/SQL package does not resemble the basic Object Pascal program structure as implemented by a Borland Delphi or Free Pascal unit. Programmers can define public and private global data-types, constants and static variables in a PL/SQL package.[3] PL/SQL also allows for the definition of classes and instantiating these as objects in PL/SQL code. This resembles usage in object-oriented programming languages like Object Pascal, C++ and Java. PL/SQL refers to a class as an "Abstract Data Type" (ADT) or "User Defined Type" (UDT), and defines it as an Oracle SQL data-type as opposed to a PL/SQL user-defined type, allowing its use in both the Oracle SQL Engine and the Oracle PL/SQL engine. The constructor and methods of an Abstract Data Type are written in PL/SQL. The resulting Abstract Data Type can operate as an object class in PL/SQL. Such objects can also persist as column values in Oracle database tables. PL/SQL is fundamentally distinct from Transact-SQL, despite superficial similarities. Porting code from one to the other usually involves non-trivial work, not only due to the differences in the feature sets of the two languages,[4] but also due to the very significant differences in the way Oracle and SQL Server deal with concurrency and locking. There are software tools available that claim to facilitate porting including Oracle Translation Scratch Editor,[5] CEITON MSSQL/Oracle Compiler [6] and SwisSQL.[7] The StepSqlite product is a PL/SQL compiler for the popular small database SQLite. PL/SQL Program Unit A PL/SQL program unit is one of the following: PL/SQL anonymous block, procedure, function, package specification, package body, trigger, type specification, type body, library. Program units are the PL/SQL source code that is compiled, developed and ultimately executed on the database. The basic unit of a PL/SQL source program is the block, which groups together related declarations and statements. A PL/SQL block is defined by the keywords DECLARE, BEGIN, EXCEPTION, and END. These keywords divide the block into a declarative part, an executable part, and an exception-handling part. The declaration section is optional and may be used to define and initialize constants and variables. If a variable is not initialized then it defaults to NULL value. The optional exception-handling part is used to handle run time errors. Only the executable part is required. A block can have a label. Package Packages are groups of conceptually linked functions, procedures, variables, PL/SQL table and record TYPE statements, constants, cursors etc. The use of packages promotes re-use of code. Packages are composed of the package specification and an optional package body. The specification is the interface to the application; it declares the types, variables, constants, exceptions, cursors, and subprograms available. The body fully defines cursors and subprograms, and so implements the specification. Two advantages of packages are: Modular approach, encapsulation/hiding of business logic, security, performance improvement, re-usability. They support object-oriented programming features like function overloading and encapsulation. Using package variables one can declare session level (scoped) variables, since variables declared in the package specification have a session scope.
Views: 13355 radhikaravikumar
Oracle Database tablespace,  Datafile and control files
 
22:43
Oracle tablespace are logical containers of datafiles. Datafiles are physical files which contains data stored in binary format. Control file contains information about the database and the datafile location as well as checkpoint information
Views: 100 joey de jesus
Oracle DB - Physical Architecture
 
05:44
Oracle DB - Physical Architecture Watch More Videos at: https://www.tutorialspoint.com/videotutorials/index.htm Lecture By: Mr. Parth Panjabi, Tutorials Point India Private Limited
Efficient Function Calls From SQL (Part 5) : Pipelined Table Functions
 
03:48
The fifth part of a mini-series of videos showing how you can improve the performance of function calls from SQL. In this episode, we compare the performance of conventions table functions with pipelined table functions. For more information see: https://oracle-base.com/articles/misc/pipelined-table-functions https://oracle-base.com/articles/misc/efficient-function-calls-from-sql Website: https://oracle-base.com Blog: https://oracle-base.com/blog Twitter: https://twitter.com/oraclebase Cameo by Mike Dietrich : Blog: https://blogs.oracle.com/UPGRADE Twitter: https://twitter.com/MikeDietrichDE Cameo appearances are for fun, not an endorsement of the content of this video.
Views: 10031 ORACLE-BASE.com
Database Tutorial 73 - SGA Database Buffer Part 2  - Oracle DBA Tutorial
 
08:10
Database Tutorial 73 - SGA Database Buffer Part 2 - Oracle DBA Tutorial
Views: 2473 Sam Dhanasekaran
PL/SQL: Dynamic SQL part-2
 
05:14
In this tutorial, you'll learn what is dynamic SQL and how to implement it.. PL/SQL (Procedural Language/Structured Query Language) is Oracle Corporation's procedural extension for SQL and the Oracle relational database. PL/SQL is available in Oracle Database (since version 7), TimesTen in-memory database (since version 11.2.1), and IBM DB2 (since version 9.7).[1] Oracle Corporation usually extends PL/SQL functionality with each successive release of the Oracle Database. PL/SQL includes procedural language elements such as conditions and loops. It allows declaration of constants and variables, procedures and functions, types and variables of those types, and triggers. It can handle exceptions (runtime errors). Arrays are supported involving the use of PL/SQL collections. Implementations from version 8 of Oracle Database onwards have included features associated with object-orientation. One can create PL/SQL units such as procedures, functions, packages, types, and triggers, which are stored in the database for reuse by applications that use any of the Oracle Database programmatic interfaces. PL/SQL works analogously to the embedded procedural languages associated with other relational databases. For example, Sybase ASE and Microsoft SQL Server have Transact-SQL, PostgreSQL has PL/pgSQL (which emulates PL/SQL to an extent), and IBM DB2 includes SQL Procedural Language,[2] which conforms to the ISO SQL’s SQL/PSM standard. The designers of PL/SQL modeled its syntax on that of Ada. Both Ada and PL/SQL have Pascal as a common ancestor, and so PL/SQL also resembles Pascal in several aspects. However, the structure of a PL/SQL package does not resemble the basic Object Pascal program structure as implemented by a Borland Delphi or Free Pascal unit. Programmers can define public and private global data-types, constants and static variables in a PL/SQL package.[3] PL/SQL also allows for the definition of classes and instantiating these as objects in PL/SQL code. This resembles usage in object-oriented programming languages like Object Pascal, C++ and Java. PL/SQL refers to a class as an "Abstract Data Type" (ADT) or "User Defined Type" (UDT), and defines it as an Oracle SQL data-type as opposed to a PL/SQL user-defined type, allowing its use in both the Oracle SQL Engine and the Oracle PL/SQL engine. The constructor and methods of an Abstract Data Type are written in PL/SQL. The resulting Abstract Data Type can operate as an object class in PL/SQL. Such objects can also persist as column values in Oracle database tables. PL/SQL is fundamentally distinct from Transact-SQL, despite superficial similarities. Porting code from one to the other usually involves non-trivial work, not only due to the differences in the feature sets of the two languages,[4] but also due to the very significant differences in the way Oracle and SQL Server deal with concurrency and locking. There are software tools available that claim to facilitate porting including Oracle Translation Scratch Editor,[5] CEITON MSSQL/Oracle Compiler [6] and SwisSQL.[7] The StepSqlite product is a PL/SQL compiler for the popular small database SQLite. PL/SQL Program Unit A PL/SQL program unit is one of the following: PL/SQL anonymous block, procedure, function, package specification, package body, trigger, type specification, type body, library. Program units are the PL/SQL source code that is compiled, developed and ultimately executed on the database.
Views: 16739 radhikaravikumar
Create table in sql | Part -3 | SQL tutorial for beginners | Tech Talk Tricks
 
04:29
Welcome to tech talk tricks and in this video we will learn how to create a table in ORACLE.So stay tuned and watch create table in sql. #TechTalkTricks #RanaSingh Basic syntax for creating table is- create table table_name(column_1 data_type(size),column_2 data_type(size)); At tech talk trick channel you will learn all kind of technology like language,tutorials and amazing computer tips and tricks. how to insert values into table in sql create table sql primary key sql create table foreign key sql create table from select create table oracle sql create table primary key autoincrement sql create database sql create temp table ************************************************** Follow Tech Talk Trick on Facebook https://www.facebook.com/techtalktricks ************************************************** Follow tech talk trick on Twitter https://twitter.com/tecktalktrick ************************************************** Follow Tech Talk Tricks on Instagram https://www.instagram.com/techtalktricks ************************************************** Subscribe tech talk tricks on YouTube https://www.youtube.com/techtalktricks *************************************************** 1.How to make your computer start up & shutdown faster https://www.youtube.com/watch?v=3kSjizTn7MM 2.How To Trace Name/Address/Location Of UnKnown Number Easily https://www.youtube.com/watch?v=kyYfOP66l1Y 3.How to make webpage print friendly https://www.youtube.com/watch?v=YPR7JHA0Apk 4.How to Lock Folder Without any software https://www.youtube.com/watch?v=BhEduEM9pws 5.How to enable undo in gmail https://www.youtube.com/watch?v=g1fOwTQ3zJg 6.How To Recover All Deleted, Formatted, Damaged Files https://www.youtube.com/watch?v=fl3DX6RBoqo 7.How to make Bootable USB pendrive for Windows https://www.youtube.com/watch?v=IXJE859pxWg 8.How to Unlock Android Pattern or Pin Lock without losing data https://www.youtube.com/watch?v=yN4JnAo7SvU 9.how to track a cell phone location for free https://www.youtube.com/watch?v=0kCLyPJ8cM0 10.How to fix or repair pendrive using cmd https://www.youtube.com/watch?v=ny4VhM2TsWM 11.how to get wifi password of neighbour https://www.youtube.com/watch?v=LCFn6IjvnMM 12.How to Send an Email In Future https://www.youtube.com/watch?v=oo84GRHe5Vg 13.How To Setup Wifi Hotspot Without Any Software in Windows 10 https://www.youtube.com/watch?v=6Bzyvs44G50 14.how to download YouTube video without any software https://www.youtube.com/watch?v=RDfDGY3Be9Y 15.HOW TO SET SHUTDOWN TIMER IN WINDOWS OS (HINDI) https://www.youtube.com/watch?v=Vb5Ou7sc4uk 16.How To convert Word File (Any File Format) to PDF file (Any File Format) https://www.youtube.com/watch?v=Nd0YtV9MwqQ 17.How To Hide Drive of Computer Using Command Prompt (Hindi) https://www.youtube.com/watch?v=AddrPKRGdSk
Views: 1021 Tech Talk Tricks
SQL Server Table Partition - Part 1
 
02:01:22
For scripts, visit www.metamanager.com SQL Server table partitioning
Views: 27465 metamanager
Oracle Internals  A Close Look at the CBO Trace
 
31:15
Oracle 10053 Trace, Cost-based Optimizer Trace Review
Views: 697 Dan Hotka
SQL: Transaction Part-1
 
06:05
In this tutorial, you'll learn what are transaction and nature of transaction. PL/SQL (Procedural Language/Structured Query Language) is Oracle Corporation's procedural extension for SQL and the Oracle relational database. PL/SQL is available in Oracle Database (since version 7), TimesTen in-memory database (since version 11.2.1), and IBM DB2 (since version 9.7).[1] Oracle Corporation usually extends PL/SQL functionality with each successive release of the Oracle Database. PL/SQL includes procedural language elements such as conditions and loops. It allows declaration of constants and variables, procedures and functions, types and variables of those types, and triggers. It can handle exceptions (runtime errors). Arrays are supported involving the use of PL/SQL collections. Implementations from version 8 of Oracle Database onwards have included features associated with object-orientation. One can create PL/SQL units such as procedures, functions, packages, types, and triggers, which are stored in the database for reuse by applications that use any of the Oracle Database programmatic interfaces. PL/SQL works analogously to the embedded procedural languages associated with other relational databases. For example, Sybase ASE and Microsoft SQL Server have Transact-SQL, PostgreSQL has PL/pgSQL (which emulates PL/SQL to an extent), and IBM DB2 includes SQL Procedural Language,[2] which conforms to the ISO SQL’s SQL/PSM standard. The designers of PL/SQL modeled its syntax on that of Ada. Both Ada and PL/SQL have Pascal as a common ancestor, and so PL/SQL also resembles Pascal in several aspects. However, the structure of a PL/SQL package does not resemble the basic Object Pascal program structure as implemented by a Borland Delphi or Free Pascal unit. Programmers can define public and private global data-types, constants and static variables in a PL/SQL package.[3] PL/SQL also allows for the definition of classes and instantiating these as objects in PL/SQL code. This resembles usage in object-oriented programming languages like Object Pascal, C++ and Java. PL/SQL refers to a class as an "Abstract Data Type" (ADT) or "User Defined Type" (UDT), and defines it as an Oracle SQL data-type as opposed to a PL/SQL user-defined type, allowing its use in both the Oracle SQL Engine and the Oracle PL/SQL engine. The constructor and methods of an Abstract Data Type are written in PL/SQL. The resulting Abstract Data Type can operate as an object class in PL/SQL. Such objects can also persist as column values in Oracle database tables. PL/SQL is fundamentally distinct from Transact-SQL, despite superficial similarities. Porting code from one to the other usually involves non-trivial work, not only due to the differences in the feature sets of the two languages,[4] but also due to the very significant differences in the way Oracle and SQL Server deal with concurrency and locking. There are software tools available that claim to facilitate porting including Oracle Translation Scratch Editor,[5] CEITON MSSQL/Oracle Compiler [6] and SwisSQL.[7] The StepSqlite product is a PL/SQL compiler for the popular small database SQLite. PL/SQL Program Unit A PL/SQL program unit is one of the following: PL/SQL anonymous block, procedure, function, package specification, package body, trigger, type specification, type body, library. Program units are the PL/SQL source code that is compiled, developed and ultimately executed on the database. The basic unit of a PL/SQL source program is the block, which groups together related declarations and statements. A PL/SQL block is defined by the keywords DECLARE, BEGIN, EXCEPTION, and END. These keywords divide the block into a declarative part, an executable part, and an exception-handling part. The declaration section is optional and may be used to define and initialize constants and variables. If a variable is not initialized then it defaults to NULL value. The optional exception-handling part is used to handle run time errors. Only the executable part is required. A block can have a label. Package Packages are groups of conceptually linked functions, procedures, variables, PL/SQL table and record TYPE statements, constants, cursors etc. The use of packages promotes re-use of code. Packages are composed of the package specification and an optional package body. The specification is the interface to the application; it declares the types, variables, constants, exceptions, cursors, and subprograms available. The body fully defines cursors and subprograms, and so implements the specification. Two advantages of packages are: Modular approach, encapsulation/hiding of business logic, security, performance improvement, re-usability. They support object-oriented programming features like function overloading and encapsulation. Using package variables one can declare session level (scoped) variables, since variables declared in the package specification have a session scope.
Views: 2603 radhikaravikumar
Managing Database Structure -Tablespaces and Datafiles part 1st
 
21:55
Hi friends in this video i am going to explain you how to create alter tablespace and datafile in oracle. Oracle database Unbeatable,Unbreakable Platform..
Views: 9805 Oracle World
Part V Oracle Database SQL Programming with PL/SQL in 2016 Primary Keys, Alter Table Definition
 
28:14
Part V Oracle 11g Database SQL Programming with PL/SQL in 2016 Primary Keys, Alter Table Definition For Notepad text files used in the video go to this link: http://www.ijav.com/oracle/
Views: 41 Jim Vincitore
High Performance Bulk Data Loading
 
33:55
What is the best way to get data into an Oracle database? This session covers how to bulk load data quickly into an Oracle database. It will help developers avoid common gotchas that will limit performance, and it gives insight into how to make sure the solution will be database AND DBA-friendly! Example SQL is used to demonstrate the solution, and links to working examples will be provided.
SQL Server In-Memory OLTP Use Case
 
05:27
SQL Server 2014 introduced in-memory features that have improved with every version since then. This week we go through an example use case of converting a staging ETL to using in-memory tables and natively compiled procedures to get huge performance gains. Related blog post with code snippets: https://bertwagner.com/2018/04/17/in-memory-oltp-a-case-study/ Twitter: https://twitter.com/bertwagner Instagram: https://www.instagram.com/bertwagner/ https://www.instagram.com/codewithbert/ Facebook: https://www.facebook.com/SQLWithBert
Views: 292 Bert Wagner
PLS-4: PL/SQL Variables
 
24:47
For Full Course Experience Please Go To http://mentorsnet.org/course_preview?course_id=5 Full Course Experience Includes 1. Access to course videos and exercises 2. View & manage your progress/pace 3. In-class projects and code reviews 4. Personal guidance from your Mentors ---------------------------------------------------------------------------------------- A variable is nothing but a name given to a storage area that our programs can manipulate. Each variable in PL/SQL has a specific data type, which determines the size and layout of the variable's memory; the range of values that can be stored within that memory and the set of operations that can be applied to the variable. The name of a PL/SQL variable consists of a letter optionally followed by more letters, numerals, dollar signs, underscores, and number signs and should not exceed 30 characters. By default, variable names are not case-sensitive. You cannot use a reserved PL/SQL keyword as a variable name. PL/SQL programming language allows to define various types of variables, which we will cover in subsequent chapters like date time data types, records, collections, etc. For this chapter, let us study only basic variable types. With PL/SQL you can declare variables and then use them in SQL and procedural statements anywhere that an expression can be used. Variables can be used for the following: • Temporary storage of data: Data can be temporarily stored in one or more variables for use when validating data input and for processing later in the data flow process. • Manipulation of stored values: Variables can be used for calculations and other data manipulations without accessing the database. • Reusability: After they are declared, variables can be used repeatedly in an application simply by referencing them in other statements, including other declarative statements. • Ease of maintenance: When using %TYPE and %ROWTYPE (more information on %ROWTYPE is covered in a subsequent lesson), you declare variables, basing the declarations on the definitions of database columns. If an underlying definition changes, the variable declaration changes accordingly at run time. This provides data independence, reduces maintenance costs, and allows programs to adapt as the database changes to meet new business needs. More information on %TYPE is covered later in this lesson. Types of Variables" All PL/SQL variables have a data type, which specifies a storage format, constraints, and valid range of values. PL/SQL supports four data type categories—scalar, composite, reference, and LOB (large object)—that you can use for declaring variables, constants, and pointers. • Scalar data types hold a single value. The main data types are those that correspond to column types in Oracle server tables; PL/SQL also supports Boolean variables. • Composite data types, such as records, allow groups of fields to be defined and manipulated in PL/SQL blocks. • Reference data types hold values, called pointers, that designate other program items. Reference data types are not covered in this course. • LOB data types hold values, called locators, that specify the location of large objects (such as graphic images) that are stored out of line. LOB data types are discussed in detail later in this course.
Views: 41049 Oresoft LWC
Oracle Data Guard Tutorial - Open the Standby Read Only (Part 2 of 4)
 
16:49
This tutorial provides a quick review of what Data Guard is, and then goes on to show how you can extract value from Data Guard in every-day usage: how you can use it to enhance performance, and to reduce (yes, reduce!) your need for Oracle licences. Opening the standby database read-only. This has in fact been possible since the automation of redo transport and redo apply when it was first introduced in release 8i. Redo is received on the standby database but is not applied. So the redo is written to the RFS, slave to standby logs, archive to standby logs into archive logs but there's no apply done. So recoverability is not compromised. There's still no danger being lots of data. You're still receiving. The thing is open read-only. What does that mean? It means you can run queries against it. You can offload all your heavyweight queries from the primary to the standby. When I say all of them, even queries that require vast massive temporary space, those horrendous queries, those doing hash joins between multi gigabyte tables, they'll be generating many gigabytes of temporary data. You can write temporary data. Provided that you're using proper temporary tablespaces which you're certain you should be, you can run any query no matter how big, no matter how much temporary data it needs. You can also write audit data and this is important because with version 11, there's quite a lot of auditing enabled by default. By default, that auditing goes to the database, writing database tables. And you can't write to a database table in a read-only database. That we can configure for automatic switching and direct the audit records to the operating system or the trail instead. The queries you run, why is this such a good facility? First, you're taking stress off the primary. I'm sure that we're all DBAs here and we all know how difficult it is to tune your database or a concurrent workload that includes both high volume DML and includes heavyweight queries. Basically, you can't tune that way at all. Offloading the queries to the physical standby will reduce a lot of stress from the primary. So your DML should run significantly better and you can even do a certain amount of tuning on the standby to tune for optimal query performance. The most obvious tuning one would do, would be the memory parameters. No one could for example give the primary a massive PGA aggregate target and the much smaller SGA target or use indeed automatic memory management, perhaps cell tuning. One can adjust many parameters to do with tuning the optimizer to drive the optimizer to a certain execution plan, to exploit the environments. All that can be done on an open read-only database. How does one do it? It really couldn't be simpler. If we look at my physical standby here, this thing database role, physical standby - and if we select the open mode from v$ database, we find this in mount mode. How do we actually open at read-only? First off, we have to stop the recovery process because remember redo is received but no applied. You have to cancel the recovery. So "alter database recover managed standby database cancel." That will give us a read consistent version of the database. The command is intelligent enough to know that there might be incomplete transactions. Long-run transactions could've been partially received. We will end up with a read consistent version. To cancel it, all we do is alter database open read-only. It is that simple.
Views: 3080 SkillBuilders
Oracle Database 18c Installation on Oracle Linux 7.5
 
30:09
In this video we are going to demonstrate how to install Oracle Database 18c in Oracle Linux 7.5. Oracle Database 18c is RDBMS software from Oracle Corporation with tons of features including Cloud Support. Oracle Database 18c installation in Oracle Linux 7 Platform is very easy. This video guides step by step installation of oracle 18c includes kernel parameters configuration, dependencies installation, oracle database installation, oracle listener configuration after installation and finally access oracle enterprise manager 18c in browser. Hardware Requirements : Enough Hard disk space, RAM and Swap Memory Software Requirements : Oracle Linux 7 with dependencies for oracle database 18c installed and Kernel Parameters configured. Important Note: To avoid Port already in use error I will be configuring hostname at the end of installation. Installation Class : Desktop class is choosen, which is easy to configure for desktops and laptops. Installation method : Offline, Oracle 18c zip file for linux downloaded and installed.
Views: 230 java frm
What types of Applications connect to a Database - DBArch  Video 17
 
05:11
In this video you will understand the difference between and Thick Client and a Middlware Client and the way they use Database connections.
Views: 3582 Ramkumar Swaminathan
How to Install Oracle! !! Database Training
 
01:50
For Complete Database Training Details Visit: http://www.qaonlinetraining.com http://infotek-solutions.com/ Delivery Method: Instructor led classroom and Online Training supported by world class Learning management system which automate all flow of lectures, videos, assignments, forums, quizzes and interview process. Class Schedule: Week-ends and Weekdays Contact Us: 571-437-0652, Mail Us: [email protected] Training Locations at : Ashburn / Fairfax / Maryland Office Address: 12801 Worldgate Dr #500, Herndon, VA 20170 Overview of Oracle DBA Training Oracle as a flexible, complex & robust RDBMS The evolution of hardware and the relation to Oracle Different DBA job roles (VP of DBA, developer DBA, production DBA, database babysitter) The changing job role of the Oracle DBA Environment management (network, CPU, disk and RAM) Instance management (managing SGA regions) Oracle table and index management Instance Architecture Instance vs. database Components of an instance Creating the OFA file structure ($DBA, bdump, udump, pfile) Oracle Instance Internals SGA vs. PGA Background processes Interfaces with server and disk I/O subsystem Using SQL*Plus for DBA management Connecting and executing SQL Using the “as sysdba” syntax Overview of SQL*Plus DBA commands (startup, etc.) Control file, UNDO and REDO management Explaining the use of control files Listing the Contents of the control File File locations for control Files Obtaining Control File Information Listing control file contents Displaying and Creating Undo segments Altering Undo Segments Determining the Number and Size of Undo segments Understanding flashback technology Troubleshooting Undo – snapshot too old Redo log concepts for recovery Online redo log (log_buffer) online redo logs and archived redo logs Oracle ARCH and LGWR background processes Redo log dictionary queries Redo log switch frequency and performance Multiplexing the Online Redo Log Files Archiving the Oracle Redo Logs Recovery using the redo log files User and privilege management The three security methods (VPD, Grant security/role-based security, grant execute) Creating New Database Users Using pre-spawned Oracle connections Auditing User activity Identifying System and Object Privileges Granting and Revoking Privileges Creating and Modifying Roles Displaying user security Information from the Data Dictionary Overview of instance management Parameter files (init.ora, listener.ora, tnsnames.ora) Rules for sizing SGA components Automated Oracle memory management (AMM) Initialization file management Creating the init.ora file Using spfile Displaying init.ora values with v$parameter Oracle*Net configuration Creating the listener.ora file Creating the tnsnames.ora file Data buffer configuration & sizing Inside the Oracle data buffers Using the KEEP pool Monitoring buffer effectiveness Using multiple blocksizes (multiple buffer pools) Shared pool and PGA configuration & Sizing Shared pool concepts and components Understanding the library cache Relieving shared pool contention Overview of PGA for sorting and hash joins Using sort_area_size, hash_area_size and pga_aggregate_target Troubleshooting network connectivity Verifying network connectivity with ping and tnsping Testing database links Oracle tables, views and materialized views Types of Oracle tables (regular, IOT, sorted hash clusters, nested tables) Oracle Views Oracle materialized views Oracle indexes Types of Oracle indexes (b-tree, bitmap, bitmap join index) Creating B*-Tree, bitmap and function-based Indexes Function-based indexes Finding indexing opportunities Index maintenance Oracle constraints Costs & benefits of constraints Types of Oracle indexes constraints (check, not null, unique, PK, FK) Cascading constraints Schema, File & tablespace management Describing the relationship between data files, tablespaces and table Understanding Oracle segments Creating Tablespaces – using the autoextend option Changing the Size of Tablespaces – alter database datafile command Defining a TEMP tablespace Changing the default storage Settings for a tablespace Review of the storage parameters in DBA views (ASM, ASSM, pctfree, pctused and freelists). Monitoring Chained rows (fetch continued rows) Monitoring Insert and Update performance (pctused, APPEND) Database Maintenance Reason for reorgs – chained rows, imbalanced freelists Reorganizing Tables using Export and Import Using CTAS to reorganize data Index rebuilding Backup & Recovery overview (hot & cold Backups, RMAN, block change tracking) Oracle DBA Utilities Data pump (Imp and exp utilities) SQL*Loader LogMiner Flashback DataGuard Oracle DBA utilities – Oracle dbms packages (dbms_redefinition)
COL2: Defining Collection Types
 
12:57
Before you can declare and work with collection variables, you have to define the type of the collection. This lesson shows you how. This video was taken from PLSQLChannel.com, originally recorded before Steven Feuerstein re-joined Oracle in March 2014. ======================================== Practically Perfect PL/SQL with Steven Feuerstein Copyright © 2015 Oracle and/or its affiliates. Oracle is a registered trademark of Oracle and/or its affiliates. All rights reserved. Other names may be registered trademarks of their respective owners. Oracle disclaims any warranties or representations as to the accuracy or completeness of this recording, demonstration, and/or written materials (the “Materials”). The Materials are provided “as is” without any warranty of any kind, either express or implied, including without limitation warranties or merchantability, fitness for a particular purpose, and non-infringement.