Home
Search results “Oracle sql user source”
Create new connection with new user in Oracle SQL Developer
 
10:28
This video shows you how to create a new connection using a new user account (other than the system user account) in Oracle SQL Developer, so that you have a clean workspace without all the clutter of system tables. It is NOT a general introduction to using Oracle SQL Developer.
Views: 295131 Chitu Okoli
Configuring Linked Server in SQL Server to connect to Oracle database
 
11:17
This tutorial is about creating database linked server in Microsoft SQL Server 2014 to connect to Oracle Database XE. You require to install Oracle instant client and configure net service name to use as data source. Example of executing dml script is mentioned in this video.
Views: 10130 Subhroneel Ganguly
Oracle SQL Tutorial 1 - Intro to Oracle Database
 
10:18
As illustrated in the video, Oracle Database is a program designed to hold lots of information, or data. There are all kinds of different databases and they all have their uses. Some of the most common ones are MySQL, SQL Server, Sybase, and MongoDB. All of these have different uses. The differences will be easier to understand after you learn more about each kind of database. We did not discuss it much in the video, but if you are wondering what “SQL” means in the title, it stands for structured query language. Structured query language is a human readable computer language that is used to tell databases to do things. We will discuss SQL and Oracle SQL Developer more in future videos. Databases are better than spreadsheets because they allow multiple users at one time, different levels of access given to users, recovery options and transactions, and it is more protected from hacking and malicious destruction. Programming languages often have very useful functions or methods that can be used to communicate to a database and therefore they are a naturally good option for the back end of programs. This course will go over all of the major parts of database programming using Oracle SQL. We will be using Oracle 11g, but these videos should still work with other versions, including the most recent 12c. Q and A ~~~~~~ How much does Oracle cost? The full enterprise edition costs thousands. They have other versions for less and they even have a FREE VERSION! This is known as the XE version (eXpress Edition). That is the one we will be using. How long does it take to learn SQL? You can learn all of the basics and be an efficient beginner database developer in only about a month of practice. To become an intermediate it can take anywhere from an additional 3 - 6 months with a only a few hours of studying and practicing each day. How can I learn SQL faster? Take notes and actually mess around with making your own database. Watch these videos until you understand the concepts within them, read articles and books that teach in more depth. Donate!: http://bit.ly/DonateCTVM2. HELP ME! http://www.patreon.com/calebcurry. Subscribe to my newsletter: http://eepurl.com/-8qtH ~~~~~~~~~~~~~~~Additional Links~~~~~~~~~~~~~~~ More content: http://CalebCurry.com Facebook: http://www.facebook.com/CalebTheVideoMaker Google+: https://plus.google.com/+CalebTheVideoMaker2 Twitter: http://Twitter.com/calebCurry Amazing Web Hosting - https://www.dreamhost.com/r.cgi?1487063 (The best web hosting for a cheap price!)
Views: 241092 Caleb Curry
Managing Oracle SQL Code with SQLDeveloper and Git in Oracle Developer Cloud Service
 
10:27
Manage the lifecycle of your Oracle database code using Oracle Developer Cloud Service. Manage versions and branch with Git, Track to-do lists, and perform code reviews. With Oracle SQLDeveloper as the dev tool. Related blog - https://blogs.oracle.com/shay/entry/managing_oracle_database_code_with
Views: 6873 ShayJDev
Oracle Tutorial | Oracle SQL Data Dictionary
 
07:06
This Oracle tutorial demonstrates how to issue SQL statements to find metadata about the tables you own. We'll take a look at the USER_TABLES, USER_CONSTRAINTS, and USER_CONS_COLUMNS data dictionary views. We'll be using SQL*Plus as our interface rather than a graphical tool such as Toad or SQL Developer. Get certified in Oracle by taking an Oracle training course with Firebox. https://www.fireboxtraining.com/oracle
Views: 2086 Firebox Training
Migrate SQL Server Database to Oracle using SQL Developer
 
09:05
This tutorial is about creating connection to Microsoft SQL Server 2008 using third party jdbc driver in Oracle SQL Developer and exporting database from SQL Server to Oracle database using export to oracle features in Oracle SQL Developer. Source to download third party jdbc driver : https://sourceforge.net/projects/jtds/?source=typ_redirect
Views: 8539 Subhroneel Ganguly
PL/SQL tutorial 49: Declare user define exception using PRAGMA EXCEPTION_INIT in Oracle Database
 
08:24
RebellionRider.com presents PL/SQL Tutorial on How to declare user define exception using PRAGMA EXCEPTION_INIT in Oracle Database by Manish Sharma ------------------------------------------------------------------------ ►►►LINKS◄◄◄ Blog: http://bit.ly/user-define-exception-3 Previous Tutorial ► User-Define Exception using RAISE_APPLICATION_ERROR https://youtu.be/k3xCWONvRxY ------------------------------------------------------------------------- ►Make sure you SUBSCRIBE and be the 1st one to see my videos! ------------------------------------------------------------------------- ►►►Find me on Social Media◄◄◄ Follow What I am up to as it happens on https://twitter.com/rebellionrider http://instagram.com/rebellionrider https://plus.google.com/+Rebellionrider http://in.linkedin.com/in/mannbhardwaj/ ___Facebook Official Page___ https://www.facebook.com/RebellionRider.official/ You can also Email me at for E-mail address please check the About section Please please LIKE and SHARE my videos it makes me happy. Thanks for liking, commenting, sharing and watching more of our videos This is Manish from RebellionRider.com ♥ I LOVE ALL MY VIEWERS AND SUBSCRIBERS
Views: 13297 Manish Sharma
How Oracle SQL Query work
 
09:22
This video will give to understanding of SQL Parsing, Syntatic check , semantic check, spool file check, Sql Optimization, row source generation and sql execution.
Views: 14728 amit wadbude
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: 8927 radhikaravikumar
Connect SQL Developer to Oracle Database Cloud Service
 
02:55
Learn how to connect to Oracle Database Cloud Service using Oracle SQL Developer ================================= To improve the video quality, click the gear icon and set the Quality to 1080p/720p HD. For more information, see http://www.oracle.com/goto/oll and http://docs.oracle.com Copyright © 2017 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.
SQL tutorial 44: How to import data from Microsoft Excel to Oracle Database using SQL Developer
 
08:21
Step by Step Oracle Database/ SQL tutorial on How to import Data from Microsoft excel to the oracle database using SQL Developer. Celebrating 1000 subscribers. Thanks a lot guys for all your love and support. ------------------------------------------------------------------------ ►►►LINKS◄◄◄ Website: www,Rebellionrider.com Create Table using ●SQL Developer & Command Prompt: http://youtu.be/UU0EEfpa-2c ●Enterprise Manager: http://youtu.be/I-LUXP9GmPU ------------------------------------------------------------------------- Copy Cloud referral link || Use this link to join copy cloud and get 20GB of free storage https://copy.com?r=kb4rc1 -------------------------------------------------------------------------- ►Make sure you SUBSCRIBE and be the first one to see my videos! -------------------------------------------------------------------------- Amazon Wishlist: http://bit.ly/wishlist-amazon ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ►►►Find me on Social Media◄◄◄ Follow What I am up to as it happens on https://twitter.com/rebellionrider https://www.facebook.com/imthebhardwaj http://instagram.com/rebellionrider https://plus.google.com/+Rebellionrider http://in.linkedin.com/in/mannbhardwaj/ http://rebellionrider.tumblr.com/ http://www.pinterest.com/rebellionrider/ You can also Email me at [email protected] Connect with me on my LinkedIn and Endorse My Skills and Do you know that I share Tips and tricks On Google+ Account? Please please LIKE and SHARE my videos it makes me happy. Thanks for liking, commenting, sharing and watching more of our videos This is Manish from RebellionRider.com ♥ I LOVE ALL MY VIEWERS AND SUBSCRIBERS
Views: 56084 Manish Sharma
SQL Developer: How To Become One?
 
06:48
► Get My BEST-SELLING Book, The Complete Software Developer's Career Guide For FREE ◄ https://simpleprogrammer.com/yt/career-guide-free ► SUBSCRIBE TO THIS CHANNEL ◄ If You want to become a successful software developer, you need to be around a community that empowers you. Subscribe to Simple Programmer: http://bit.ly/subscribesimpleprogrammer ► THE COMPLETE SOFTWARE DEVELOPER'S CAREER GUIDE ◄ Get #1 bestselling book, The Complete Software Developer's Career Guide https://simpleprogrammer.com/careerguide-yt ► SQL Developer: How To Become One? ◄ " Oracle SQL Developer is the Oracle Database IDE. A free graphical user interface, Oracle SQL Developer allows database users and administrators to do their database tasks in fewer clicks and keystrokes. A productivity tool, SQL Developer's main objective is to help the end user save time and maximize the return on investment in the Oracle Database technology stack." (Source: http://www.oracle.com/technetwork/developer-tools/sql-developer/what-is-sqldev-093866.html) Becoming a SQL developer is not something we see very often. There is not so much talk about SQL developers on the internet, so, people who want to become one might get lost. How do you become a SQL Developer? Watch this video and find out! Learn Cobol Programming? (2018 & Beyond): https://www.youtube.com/watch?v=f3WVa2zyyGE Should You Focus On Getting Certifications?: https://www.youtube.com/watch?v=-LAzOBhIfPE ► BUY "TRUST THE PROCESS" SHIRT ◄ Buy "Trust The Process" Shirt and remember this powerful concept that can literally transform your life: https://store.simpleprogrammer.com/ ► SUBSCRIBE TO OUR EMAIL NEWSLETTER ◄ This is the best way to have the BEST programming career tips delivered to your inbox, simple and easy. http://simpleprogrammer.com/email ► LINKS YOU MIGHT LIKE ◄ Simple Programmer Website: http://simpleprogrammer.com/ PATREON PAGE: https://www.patreon.com/simpleprogrammer How To Market Yourself Course: http://simpleprogrammer.com/howtomarketyourself 10 Steps To Learn Anything Quickly Course: http://simpleprogrammer.com/10stepstolearn Soft Skills Book: http://simpleprogrammer.com/softskills FREE Blogging Course: http://simpleprogrammer.com/blog-course Buy Simple Programmer SHIRT: https://store.simpleprogrammer.com/ Facebook: https://www.facebook.com/SimpleProgrammer Twitter: https://twitter.com/jsonmez Coaching Services: https://simpleprogrammer.com/coaching-services/ If you have a question, email me at [email protected]
Views: 14796 Bulldog Mindset
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: 2476 radhikaravikumar
SQL: LEAD Function
 
06:30
In this tutorial, you'll learn how to make use of lead function in oracle sql 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: 1376 radhikaravikumar
Oracle Database - SQL Bangla Tutorial | Real Life Database Design Project | PL SQL | Training
 
01:18:39
See the Description for required source code and links SQL Tutorial Source Code of Oracle Database 11g Training: https://drive.google.com/open?id=0Bz0MNaVyRm3lTWxqR1F3b0tGZ3M Chapter-11 & 12: Real Life Oracle Database Design Project . In this video tutorial, you will know real life database design project. This is special computer training designing online courses on Database Management System. It is fully bangla tutorial. It will be helpful for every database programmer and administrator. Subscribe this channel to watch my all tutorials on PHP, MYSQL, Javascript, Linux, Networking, Access Programming & Microsoft Office, C++, HTML, CSS. Oracle Database PDF eBook Link : https://drive.google.com/open?id=0Bz0MNaVyRm3lUWpGbXMyX3lRUTg All Source Codes & Required Documents together are found in the link: https://drive.google.com/open?id=0Bz0MNaVyRm3lMjFVcXhzMjNvWDA All SQL & PL SQL Tutorials are found in the link: https://www.youtube.com/playlist?list=PLUYY2piVmub7QL0ET2_eg4D_SV3AOsPHT Oracle DBA Tutorials: https://www.youtube.com/playlist?list=PLUYY2piVmub6bRM0ScQMNnbyH66yrh1cf Channel Link: http://www.youtube.com/channel/UCT_fWLNX67sDH3W3FZ1wxLg?sub_confirmation=1 Required Document Link : https://drive.google.com/open?id=0Bz0MNaVyRm3lWDB0V1JOOE93eUE FB Page: https://www.facebook.com/BanglaTutorial24 FB Group: https://www.facebook.com/groups/banglatutorial24/ In the tutorial, I have tried to describe about how to manage real life database design project. [SQL TUTORIAL, DATABASE MANAGEMENT SYSTEM, BANGLA TUTORIAL, TRAINING, DATABASE, ORACLE DATABASE]
Views: 6824 MD. SHARIFUL ALAM
How to connect to an Oracle Database? - Database Tutorial 37
 
12:37
Video 37 - How to connect to a Oracle Database? - Database Tutorial 37 This video explains how to connection to an oracle database. The database, which is Oracle 11g has been installed in a Windows 7 computer.
Views: 101733 Sam Dhanasekaran
SQL: Change User Password
 
02:38
In this tutorial, you'll learn how to change user password in sql plus 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: 6617 radhikaravikumar
PL/SQL Tutorial 1 (Oracle): Importing data from an Excel Spreadsheet
 
03:43
PL/SQL Tutorial 1 (Oracle): Importing data from an Excel Spreadsheet In this tutorial I show you how to import data from excel into a table in Oracle PL/SQL Developer. Source Code: https://github.com/mitchtabian/SQL-tutorials Subscribe to my Blog and YouTube channel to get notifications when new FREE coding tutorials are posted! Blog: http://www.codingwithmitch.com/
Views: 7200 CodingWithMitch
Oracle DBaaS: Connecting from SQL Developer
 
02:37
The administrator password you provide is used for the SYS and SYSTEM database users, for the admin Oracle GlassFish Server user, and for the admin Oracle Application Express user.
Views: 1341 Ora Tube
Oracle SQL Tutorial 3 - Downloading Oracle Database and Installing SQL Developer
 
10:18
This tutorial will take you through the process of downloading the oracle database, Oracle SQL Developer, and then teach you how to connect the Oracle SQL Developer to the database. We will be discussing how to access the advanced settings but will not be going in depth about all of the options. HELP ME! http://www.patreon.com/calebcurry Subscribe to my newsletter: http://eepurl.com/-8qtH Donate!: http://bit.ly/DonateCTVM2. ~~~~~~~~~~~~~~~Additional Links~~~~~~~~~~~~~~~ More content: http://CalebCurry.com Facebook: http://www.facebook.com/CalebTheVideoMaker Google+: https://plus.google.com/+CalebTheVideoMaker2 Twitter: http://Twitter.com/calebCurry Amazing Web Hosting - https://www.dreamhost.com/r.cgi?1487063 (The best web hosting for a cheap price!)
Views: 67555 Caleb Curry
Break free from Oracle with SQL Server 2017
 
01:30
Learn about SQL Server 2017 and how it is superior to Oracle as a database management platform. For more information on migrating from Oracle, visit: https://www.microsoft.com/en-us/sql-server/sql-license-migration
Views: 1535 Microsoft Cloud
Oracle SQL Tutorial 18 - How to Create Foreign Keys
 
07:09
In this video we are going to be creating foreign keys. I highly recommend watching the previous video before you watch this one. Essentially, we are creating a very simple database for a system where we can create projects and add people to those projects. We started with the users table: --Delete the table if needed: --DROP TABLE users; CREATE TABLE users( user_id NUMBER, username VARCHAR2(50 CHAR) UNIQUE, CONSTRAINT users_pk PRIMARY KEY (user_id) ); Now we are going to create a table for projects with a column that is a foreign key to the username. We're going to want to make this match data types: CREATE TABLE projects( project_id NUMBER, project_name VARCHAR2(50 CHAR) UNIQUE, creator VARCHAR2(50 CHAR) ) Next, we need to add the column attributes we decided on last video: CREATE TABLE projects( project_id NUMBER, project_name VARCHAR2(50 CHAR) UNIQUE, creator VARCHAR2(50 CHAR) NOT NULL ) NOT NULL because we want every project to have a creator, but we are not labeling UNIQUE because that means we could only have a specific username once in the table. We want to allow a user to create multiple projects. We also need to add a primary key: CREATE TABLE projects( project_id NUMBER, project_name VARCHAR2(50 CHAR) UNIQUE, creator VARCHAR2(50 CHAR) NOT NULL, CONSTRAINT projects_pk PRIMARY KEY (username) ) Now, the question that remains is, how can I tell Oracle that I want the username to reference the username column of the other table? We have to make a foreign key constraint. As you've learned from the previous videos, there are about three ways to create constraints. You can do it inline at the column level, unnamed. You can do it at the column level, named, and you can do it at the Table level, named. Usually the table-level is preferred, but I will quickly remind you how to do all three again. CREATE TABLE projects( project_id NUMBER, project_name VARCHAR2(50 CHAR) UNIQUE, creator VARCHAR2(50 CHAR) NOT NULL REFERENCES users (username), CONSTRAINT projects_pk PRIMARY KEY (project_id) ) This works, but if we want to name it, we should do this: CREATE TABLE projects( project_id NUMBER, project_name VARCHAR2(50 CHAR) UNIQUE, creator VARCHAR2(50 CHAR) NOT NULL CONSTRAINT projects_users_fk REFERENCES users (username), CONSTRAINT projects_pk PRIMARY KEY (project_id) ) This works, but the preferred method is to do it at the table level: CREATE TABLE projects( project_id NUMBER, project_name VARCHAR2(50 CHAR) UNIQUE, creator VARCHAR2(50 CHAR) NOT NULL, CONSTRAINT projects_pk PRIMARY KEY (project_id), CONSTRAINT projects_users_fk FOREIGN KEY (creator) REFERENCES users (username) ) Great! So you've learned how to create a foreign key, now we can see it inside of Oracle SQL Developer. One important thing when it comes to foreign keys is what happens when have data in your database and you try to delete the parent row that a row in the child table references? In the next video we are going to configure that using ON DELETE. See you all then and if you enjoy this series, please do me a huge favor by liking the video and subscribing to my YouTube channel. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ HELP ME! http://www.patreon.com/calebcurry Subscribe to my newsletter: http://eepurl.com/-8qtH Donate!: http://bit.ly/DonateCTVM2. ~~~~~~~~~~~~~~~Additional Links~~~~~~~~~~~~~~~ More content: http://CalebCurry.com Facebook: http://www.facebook.com/CalebTheVideoMaker Google+: https://plus.google.com/+CalebTheVideoMaker2 Twitter: http://twitter.com/calebCurry Amazing Web Hosting - https://www.dreamhost.com/r.cgi?1487063 (The best web hosting for a cheap price!)
Views: 14142 Caleb Curry
Using Git with Oracle SQL Developer
 
06:24
How to configure Oracle SQL Developer to use Git
Views: 2992 Blaine Carter
How to Connect MS SQL Server Database with Oracle SQL Developer
 
05:38
how to connect sql server with sql developer how to connect sql server with sql develope How to Connect MS SQL Server Database with Oracle SQL Developer jtds - sql server and sybase jdbc driver cannot connect to microsoft sql server on localhost sql developer jtds-1.2.5.jar oracle sql developer oracle sql server download native sspi library not loaded sql developer jtds 3rd party jdbc driver oracle sql developer connect to microsoft sql server jtds-1.2.5.jar oracle sql developer jtds - sql server and sybase jdbc driver sql developer connect to sql server named instance jtds 3rd party jdbc driver sql developer cannot connect to microsoft sql server how to connect sql server with sql developer
Views: 4137 Oracle PL/SQL World
SQL: Sequence Generator
 
04:41
In this tutorial, you'll learn how to make use of sequence generator. 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: 6240 radhikaravikumar
Oracle SQL Tutorial 16 - Parent Child Relationships
 
06:09
So far in this series we have discussed database design, creating tables, and constraints. We've brought up the concept of foreign keys, but we have not explained how to create them. That is the goal of this video and the upcoming videos. We want to study those foreign keys! Let's make them not so foreign. Let's learn the proper way to define a foreign key. As a reminder, a foreign key is a column that references a column of another table. The column it references must either be a primary key, or have the UNIQUE constraint. This means that every value inside of the column that is labeled as a foreign key, there must be that value in some row of the referenced column. As an example, imagine that we have the users table, and we have a table service_requests. We could have a column in the service_request that references a column in the users table. Usually this would be the primary key that is referenced, but there is nothing stopping you from referencing a unique column. Just for fun, let's go through an example using the username column. If we have a service_requests table, every single row within the table is going to be what some would consider an instance of a service_request. This means that the table columns are like the blueprint for what a service request looks like and then each row is an individual service request. If we have one of the columns labeled as a foreign key to the username of the users table, what does that mean practically? It means that for a single row, the value for that column must be a value that exists in the users table. We could have a service_request submitted by a user with the username of Yoloswagman. This means that there must be a row inside of the users table that has the value Yoloswagman for the username column. This brings up the concept of parent and child relationships. Yoloswagman in this situation is the parent, and his service request is the child. When we draw it out, it makes sense why a primary key must be UNIQUE. If we had two Yoloswagmans, the child would not know which column is the parent. The same applies if we were using IDs and we had So remember, always reference a primary key or a column with the UNIQUE constraint. Now, I have a question for you. Do foreign keys automatically have the UNIQUE constraint, just like primary keys? The answer is no. A parent row can have many child rows. It makes sense because the user could submit multiple service requests. Can we force the column to be unique? Absolutely. If that was the case, the user could only make one service request. Another question. Do foreign keys automatically have the NOT NULL constraint, just like primary keys? The answer is no. Essentially what this means is that a child could be created with no parent. Can we force the column to be NOT NULL? Absolutely. It is ok in some situations to allow the row to be null, but in this situation it makes no sense. It would be wise for us to add that constraint ourselves. So now that you understand some more differences between primary and foreign keys and parent child relationships, take all of these questions into consideration when you are creating foreign keys. In the next video, we are going to start a small project that is going to require multiple tables. We'll take a video to design our structure and then we'll get to creating those foreign keys in Oracle SQL Developer. Stick around and if you like these videos please be a serious supporter and subscribe to my channel. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ HELP ME! http://www.patreon.com/calebcurry Subscribe to my newsletter: http://eepurl.com/-8qtH Donate!: http://bit.ly/DonateCTVM2. ~~~~~~~~~~~~~~~Additional Links~~~~~~~~~~~~~~~ More content: http://CalebCurry.com Facebook: http://www.facebook.com/CalebTheVideoMaker Google+: https://plus.google.com/+CalebTheVideoMaker2 Twitter: http://twitter.com/calebCurry Amazing Web Hosting - https://www.dreamhost.com/r.cgi?1487063 (The best web hosting for a cheap price!)
Views: 8223 Caleb Curry
Oracle SQL - Client Server Architecture - Lesson 05
 
02:23
Learn about Client Server architecture in Oracle Database environment. This video explains about it.
Views: 5405 Sam Dhanasekaran
Informatica MDM User Exits Oracle PL SQL PACKAGE from Java | Informatica MDM java Package
 
05:48
Want to do Informatica MDM the right way in 2018? Then check out this insanely actionable Informatica MDM tutorial. In this video I'll explain Informatica MDM and User Exits Oracle PL SQL PACKAGE from Java You can always contact me on [email protected] Website:https://www.asha24.com Linkedin: https://www.linkedin.com/company/13348538/ Facebook: https://www.facebook.com/Asha24PvtLtd/ Twitter: https://twitter.com/asha24Inc Subscribe to my channel to get video updates. Hit the subscribe button. Thanks
Views: 189 Asha24
SQL: Delete Vs Truncate Vs Drop
 
08:27
In this tutorial, you'll learn the difference between delete/drop and truncate. 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: 50301 radhikaravikumar
PL/SQL: Object Type
 
08:31
In this tutorial, you'll learn what is a object type in sql/plsql 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: 10821 radhikaravikumar
PL/SQL: Coalesce Function
 
04:36
In this tutorial, you'll learn how to make use of coalesce function in oracle SQL. 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: 1889 radhikaravikumar
Connect Excel to Oracle Database
 
05:03
How to connect an Oracle Database to Microsoft Excel. https://www.elance.com/s/edtemb/
Views: 90028 i_marketing
Using Oracle to read data from SQL Server
 
10:47
Hi everyone, Andy from Easysoft Limited here, what I want to show you today is how to get data from SQL Server into Oracle. Now for this we will be accessing SQL Server 2014 from Oracle 12 and getting data across. This could be quite easily be any SQL Server version from 2008 and any Oracle version from 11.2, the configuration and process is the same. We can obviously get access to data on SQL Server prior to 2008 and Oracle prior to version 11.2 but it will need a different configuration to what I am going to show you today The plan is also to add more data to the SQL Server table and show this new data back in Oracle. To start off you'll need access to ensure that you have access to your SQL Server and Oracle databases. You'll also need the Easysoft SQL Server ODBC Driver available from www.easysoft.com; just download it, install it and request the free 14 day trial licence. Before we start we need to make some changes to the standard Easysoft config files. cat /etc/odbc.ini Here I have changed Mars Connection to Yes. It must be set to "Yes" if you are connecting to SQL Server 2005 or newer. Easysoft supports all SQL data types from the version of SQL Server from version 7. Oracle supports data types that are common to most ODBC Drivers, but not some of the SQL Server ones. If you intend to access VARCHAR(MAX) for example, then there are some additional settings that need to be set up. Now as I would like to show you VARCHAR(MAX) data moving from SQL Server to Oracle, I have made the relevant change. As you can see, VarMaxAsLong says "Yes" We now need to create a link from Oracles Database Gateway (DG4ODBC) to the ODBC datasource that we already have, this is done in an init(sid) oracle file; let's have a look at our file. cat $ORACLE_HOME/hs/admin/initsqlsrv.ora Please note that HS_NLS_NCHAR must be set to UCS2 Oracle assume that most database vendors use UTF-8 for wide characters, however Easysoft, like almost all ODBC Driver vendors (including Oracles own ODBC Driver) uses UCS2 for wide characters. So that's the link between DG4ODBC and the datasource setup correctly. Next we need to set up the Listener entry The Oracle Listener waits for incoming requests from the Oracle database. For the Oracle Listener to listen for requests, information about DG4ODBC must be added to the Oracle Listener configuration file, listener.ora cat $ORACLE_HOME/network/admin/listener.ora The PROGRAM=dg4odbc tells the Listener that we are wanting to use the Oracle database gateway to communicate with ODBC. The ENVS=LD_LIBRARY_PATH tells Oracle what library to load Now that's all set up and OK we need to tell Oracle which server to attach the listener entry to. This is done in tnsnames.ora, and he is the file that we ensured was set up earlier. cat $ORACLE_HOME/network/admin/tnsnames.ora The Oracle Listener now needs to be restarted. lsnrctl stop lsnrctl start OK, that's now started the Listener up again. So we have ensured that all the configuration files are set up correctly. The Listener and tnsnames.ora both set up OK. The final step is to create a link from the Oracle database to the "tnsnames.ora" entry. CREATE PUBLIC DATABASE LINK ODBC CONNECT TO "test" IDENTIFIED BY "test" USING 'sqlsrv_ptr'; Right, that's all done. Let's access the data in SQL Server now. select * from [email protected]; Where 'demo' is the name of the SQL Server table and 'odbc' is the public database link name. OK, there we have the data. So to recap, I'm in Oracle and we have managed to read the data from SQL Server. Let's just add an additional row in that SQL Server table and retrieve the new data in Oracle. quit; /usr/local/easysoft/unixODBC/bin/isql.sh -v sqlsrv insert into demo values (2,'Easysoft') select * from demo select * from [email protected]; And there is the new data. Easysoft Limited can help you with your data access ... for our full range of ODBC and JDBC Drivers, Bridges and Gateways visit easysoft.com Be sure to let us know if you have any comments or questions. Until next time, thanks again and we'll see you again soon.
Views: 14309 Easysoft Limited
Oracle SQL Developer: Online Migration 3.1
 
10:01
Using Oracle SQL Developer 3.1 to migrate a Sybase database to Oracle.
Views: 59927 oraclesqldev
DYN1: Introduction to Dynamic SQL in PL/SQL (PL/SQL Channel)
 
14:32
This video explains the difference between static and dynamic SQL, reviews the four methods of dynamic SQL, and lays out the plan for this series. It 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.
How to Create a Migration Repository in Oracle SQL Developer
 
02:54
This demo will show how to create a migration repository in Oracle SQL Developer. The migration repository is a database schema that stores the meta data collected and transformed in the migration process. Copyright © 2013 Oracle and/or its affiliates. Oracle® is a registered trademark of Oracle and/or its affiliates. All rights reserved. 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 of merchantability, fitness for a particular purpose, and non-infringement.
The Privileged User Controls in the Oracle Public Cloud
 
02:00
Oracle CTO and Executive Chairman of the Board, Larry Ellison, talks about separation of duties between users and technical administrators of cloud data and systems.
Views: 446 Oracle Cloud
SQL: ACID (Transaction properties)
 
06:34
In this tutorial, you'll learn what is ACID 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: 2232 radhikaravikumar
Oracle Database Tutorial 70: IO ERROR: The network adapter could not establish the connection
 
03:34
IO ERROR: The network adapter could not establish the connection Learn how to solve this Oracle Database / SQL Developer Error with in 4 minutes ------------------------------------------------------------------------ ►►►LINKS◄◄◄ Blog : http://bit.ly/sql-developer-error-the-network-adapter-could-not-establish-the-connection Previous Tutorial ► Intersect and Minus SQL set operators https://youtu.be/sDZFpwEw1k8 ------------------------------------------------------------------------- ►►►Let's Get Free Uber Cab◄◄◄ Use Referral Code UberRebellionRider and get $20 free for your first ride. ------------------------------------------------------------------------- ►►►Help Me In Getting A Job◄◄◄ ►Help Me In Getting A Good Job By Connecting With Me on My LinkedIn and Endorsing My Skills. All My Contact Info is Down Below. You Can Also Refer Me To Your Company Thanks ------------------------------------------------------------------------- Copy Cloud referral link || Use this link to join copy cloud and get 20GB of free storage https://copy.com?r=kb4rc1 -------------------------------------------------------------------------- ►Make sure you SUBSCRIBE and be the 1st one to see my videos! -------------------------------------------------------------------------- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ►►►Find me on Social Media◄◄◄ Follow What I am up to as it happens on https://twitter.com/rebellionrider https://www.facebook.com/imthebhardwaj http://instagram.com/rebellionrider https://plus.google.com/+Rebellionrider http://in.linkedin.com/in/mannbhardwaj/ http://rebellionrider.tumblr.com/ http://www.pinterest.com/rebellionrider/ You can also Email me at for E-mail address please check About section Please LIKE and SHARE my videos it makes me happy. Thanks for liking, commenting, sharing and watching more of our videos This is Manish from RebellionRider.com ♥ I LOVE ALL MY VIEWERS AND SUBSCRIBERS
Views: 124462 Manish Sharma
Power BI direct connect to SQL database (7-3)
 
04:40
This video is part of the Analyzing and Visualizing Data with Power BI course available on EdX. To sign up for the course, visit: http://aka.ms/pbicourse. To read more: Power BI service https://aka.ms/pbis_gs Power BI Desktop https://aka.ms/pbid_gs Power BI basic concepts tutorial: https://aka.ms/power-bi-tutorial To submit questions and comments about Power BI, please visit community.powerbi.com.
Views: 29166 Microsoft Power BI
SQL: Extract function
 
03:38
In this tutorial, you'll learn how to make use of extract function. 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: 2623 radhikaravikumar
What is the difference between Oracle and SQL Server
 
02:07
What is the difference between Oracle and SQL Server - Find out more explanation for : 'What is the difference between Oracle and SQL Server' only from this channel. Information Source: google
Views: 11 wikiaudio14
How to Install Oracle SQL Developer 4 on on RHEL/CentOS 6/7 and Fedora 23/21/20 - Desktop
 
11:51
Hello Everyone, In this tutorial, Let Us Install Oracle SQL Developer 4 in Fedora Workstation 21,20 - 64Bit You Can also Install in CentOS 7, Oracle Linux, Cloud Linux, Redhat Linux 7 . Installation Requirements 1. SQL Developer - 232MB(Download Size) - 304MB(Installation Size) 2. JDK 7 - 136MB(Download Size) - 285MB(Installation Size) Note :- Total disk space required, including 600 MB For installation processing: 1.6 GB Installing Oracle JDK Step1 :- uname –m If the command output is x86_64 you need to download Java for x64 (64-bit), otherwise, if it shows i686 or similar, you need to download Java for x86 (32-bit). Downloading Java JDK Step1 :- Java SE Development Kit 7 or 8 Downloads http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html Step2 :- cd Downloads Step3 :- sudo mkdir -p /usr/java Step4 :- sudo tar -zxf jdk-7*.tar.gz -C /usr/java Step5 :- ls /usr/java Step6 :- sudo ln -sf /usr/java/jdk1.7.0_60 /usr/java/jdk Step7 :- ls /usr/java/jdk Downloading SQL Developer Step1 :- Installing SQL Developer Downloads http://www.oracle.com/technetwork/developer-tools/sql-developer/downloads/index.html Step2 :- cd Downloads Step3 :- ls sqldev* Right Click on Sql Developer download file than extract it there. Step4 :- ls /opt/sqldeveloper Step5 :- ls -l $(which sqldeveloper) Step6 :- a=$(which sqldeveloper) Step7 :- ls -l /usr/java/jdk Step8 :- sudo sed -i "1 i unset GNOME_DESKTOP_SESSION_ID" $a Step9 :- sudo sed -i "1 i export JAVA_HOME=/opt/java/jdk" $a Step10 :- cat $a SQL Developer Settings Step20 :- cd Step21:- ls -l .sqldeveloper Step22 :- rm -rf .sqldeveloper Uninstalling SQL Developer Step23 :- sudo yum remove sqldeveloper Remove your personal SQL Developer settings (optional). Step24 :- rm -rf $HOME/.sqldeveloper Uninstalling Oracle Java JDK Step25 :- sudo rm -rf /opt/java Error’s You may receive the following error: "...launcher.sh: line 1559: /opt/java/jdk/bin/java: cannot execute binary file: Exec format error...". This error means that the Java installation does not meet the computer's system architecture. You can check the following: Step26 ;- /usr/java/jdk/bin/java Step27 :- uname -m NOTE :- For Any Clarification Please Below Comment, Like and Share  us  and  help us to spread. ####--------------------------------------------------------------------------------------#### Subscribe :- http://www.youtube.com/user/itcloudnet?sub_confirmation=1 Website :- http://www.cloudnetwork.in Facebook :- http://facebook.com/itCloudNetwork/ Twitter :- http://twitter.com/itcloudnet Pinterset :- http://pinterset.com/itcloudnet LinkedIn :- http://in.linkedin.com/pub/itcloudnet Google+ :- https://plus.google.com/u/0/107923552480070716949/posts Skype Id :- cloud.network1 E-Mail Id :- [email protected] ####---------------------------------------------------------------------####                          Thanking You Hope U Like it........
Views: 6542 Cloud Network
Oracle username and password and Account unlocking
 
08:37
all education purpose videos
Views: 246573 Chandra Shekhar Reddy
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: 13060 radhikaravikumar
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: 5646 radhikaravikumar