https://glossar.hs-augsburg.de/w/api.php?action=feedcontributions&feedformat=atom&user=ThoeferGlossarWiki - Benutzerbeiträge [de-formal]2026-07-18T18:52:48ZBenutzerbeiträgeMediaWiki 1.43.3https://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=13060Ruby (Programmiersprache)2009-07-16T15:21:56Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[JRuby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Paradigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer. Mehr noch: Sogar Klassen sind Klassenobjekte. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Mixins: Module können in Klassen "eingemischt" werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
=Metaprogrammierung, Codebeispiele=<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
# Hier wird nur dem Objekt a eine Methode hinzugefügt<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
Metaprogrammierung mit class_eval<br />
<source lang="ruby"><br />
<br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
# Ab sofort gibt es für Auto-Klassen auch eine bremsen-Methode<br />
Auto.class_eval do<br />
def bremsen<br />
"quieeeetscch......"<br />
end<br />
end<br />
<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => "quieeeetscch......"<br />
<br />
</source><br />
class_eval evaluiert einen übergebenen Block oder String im Klassenkontext. <br />
<br />
<br />
<source lang="ruby"><br />
method_name = "bremsen"<br />
Auto.class_eval <<-END<br />
def #{method_name}; "quieetsch....."; end; <br />
END<br />
</source><br />
class_eval mit übergebenem String<br />
<br />
<br />
Meta-Programmierung: Die Hookmethode method_missing:<br />
<source lang="ruby"><br />
class Bike <br />
def method_missing(name, *args)<br />
puts "die methode #{name} mit den parametern #{args.join(", ")} existiert nicht."<br />
end<br />
end<br />
<br />
b = Bike.new<br />
puts b.rahmentypen "carbon", "edelstahl"<br />
</source><br />
method_missing wird aufgerufen wenn eine Methode nicht existiert.<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
* [http://home.vr-web.de/juergen.katins/ruby/buch/] Pickaxe-Buch auf deutsch<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
*http://tryruby.hobix.com/ #Try Ruby in your browser<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}<br />
<br />
[[Kategorie:Ruby]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12921Ruby (Programmiersprache)2009-07-09T10:50:10Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[JRuby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Paradigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer. Mehr noch: Sogar Klassen sind Klassenobjekte. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Mixins: Module können in Klassen "eingemischt" werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
=Metaprogrammierung, Codebeispiele=<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
# Hier wird nur dem Objekt a eine Methode hinzugefügt<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
Metaprogrammierung mit class_eval<br />
<source lang="ruby"><br />
<br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
# Ab sofort gibt es für Auto-Klassen auch eine bremsen-Methode<br />
Auto.class_eval do<br />
def bremsen<br />
"quieeeetscch......"<br />
end<br />
end<br />
<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => "quieeeetscch......"<br />
<br />
</source><br />
class_eval evaluiert einen übergebenen Block oder String im Klassenkontext. <br />
<br />
<br />
<source lang="ruby"><br />
method_name = "bremsen"<br />
Auto.class_eval <<-END<br />
def #{method_name}; "quieetsch....."; end; <br />
END<br />
</source><br />
class_eval mit übergebenem String<br />
<br />
<br />
Meta-Programmierung: Die Hookmethode method_missing:<br />
<source lang="ruby"><br />
class Bike <br />
def method_missing(name, *args)<br />
puts "die methode #{name} mit den parametern #{args.join(", ")} existiert nicht."<br />
end<br />
end<br />
<br />
b = Bike.new<br />
puts b.rahmentypen "carbon", "edelstahl"<br />
</source><br />
method_missing wird aufgerufen wenn eine Methode nicht existiert.<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
* [http://home.vr-web.de/juergen.katins/ruby/buch/] Pickaxe-Buch auf deutsch<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
*http://tryruby.hobix.com/ #Try Ruby in your browser<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12920Ruby (Programmiersprache)2009-07-09T10:48:58Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[JRuby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Paradigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer. Mehr noch: Sogar Klassen sind Klassenobjekte. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Mixins: Module können in Klassen "eingemischt" werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
# Hier wird nur dem Objekt a eine Methode hinzugefügt<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
Metaprogrammierung mit class_eval<br />
<source lang="ruby"><br />
<br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
# Ab sofort gibt es für Auto-Klassen auch eine bremsen-Methode<br />
Auto.class_eval do<br />
def bremsen<br />
"quieeeetscch......"<br />
end<br />
end<br />
<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => "quieeeetscch......"<br />
<br />
</source><br />
class_eval evaluiert einen übergebenen Block oder String im Klassenkontext. <br />
<br />
<br />
<source lang="ruby"><br />
method_name = "bremsen"<br />
Auto.class_eval <<-END<br />
def #{method_name}; "quieetsch....."; end; <br />
END<br />
</source><br />
class_eval mit übergebenem String<br />
<br />
<br />
Meta-Programmierung: Die Hookmethode method_missing:<br />
<source lang="ruby"><br />
class Bike <br />
def method_missing(name, *args)<br />
puts "die methode #{name} mit den parametern #{args.join(", ")} existiert nicht."<br />
end<br />
end<br />
<br />
b = Bike.new<br />
puts b.rahmentypen "carbon", "edelstahl"<br />
</source><br />
method_missing wird aufgerufen wenn eine Methode nicht existiert.<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
* [http://home.vr-web.de/juergen.katins/ruby/buch/] Pickaxe-Buch auf deutsch<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
*http://tryruby.hobix.com/ #Try Ruby in your browser<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12918Ruby (Programmiersprache)2009-07-09T10:39:20Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[JRuby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Paradigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer. Mehr noch: Sogar Klassen sind Klassenobjekte. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Mixins: Module können in Klassen "eingemischt" werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
# Hier wird nur dem Objekt a eine Methode hinzugefügt<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
Metaprogrammierung mit class_eval<br />
<source lang="ruby"><br />
<br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
# Ab sofort gibt es für Auto-Klassen auch eine bremsen-Methode<br />
Auto.class_eval do<br />
def bremsen<br />
"quieeeetscch......"<br />
end<br />
end<br />
<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => "quieeeetscch......"<br />
<br />
</source><br />
class_eval evaluiert einen übergebenen Block oder String im Klassenkontext. <br />
<br />
<br />
<source lang="ruby"><br />
method_name = "bremsen"<br />
Auto.class_eval <<-END<br />
def #{method_name}; "quieetsch....."; end; <br />
END<br />
</source><br />
class_eval mit übergebenem String<br />
<br />
<br />
Meta-Programmierung: Die Hookmethode method_missing:<br />
<source lang="ruby"><br />
class Bike <br />
def method_missing(name, *args)<br />
puts "die methode #{name} mit den parametern #{args.join(", ")} existiert nicht."<br />
end<br />
end<br />
<br />
b = Bike.new<br />
puts b.rahmentypen "carbon", "edelstahl"<br />
</source><br />
method_missing wird aufgerufen wenn eine Methode nicht existiert.<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12917Ruby (Programmiersprache)2009-07-09T10:21:50Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[JRuby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Paradigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer. Mehr noch: Sogar Klassen sind Klassenobjekte. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Mixins: Module können in Klassen "eingemischt" werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
# Hier wird nur dem Objekt a eine Methode hinzugefügt<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
Metaprogrammierung mit class_eval<br />
<source lang="ruby"><br />
<br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
# Ab sofort gibt es für Auto-Klassen auch eine bremsen-Methode<br />
Auto.class_eval do<br />
def bremsen<br />
"quieeeetscch......"<br />
end<br />
end<br />
<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => "quieeeetscch......"<br />
<br />
</source><br />
class_eval evaluiert einen übergebenen Block oder String im Klassenkontext. <br />
<br />
<br />
<source lang="ruby"><br />
method_name = "bremsen"<br />
Auto.class_eval <<-END<br />
def #{method_name}; "quieetsch....."; end; <br />
END<br />
</source><br />
class_eval mit übergebenem String<br />
<br />
<br />
Meta-Programmierung, send():<br />
<source lang="ruby"><br />
<br />
</source><br />
<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12916Ruby (Programmiersprache)2009-07-09T10:09:56Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[JRuby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Prardigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer und sogar Klassen werden als Objekte behandelt. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Mixins: Module können in Klassen "eingemischt" werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
# Hier wird nur dem Objekt a eine Methode hinzugefügt<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
Metaprogrammierung mit class_eval<br />
<source lang="ruby"><br />
<br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
# Ab sofort gibt es für Auto-Klassen auch eine bremsen-Methode<br />
Auto.class_eval do<br />
def bremsen<br />
"quieeeetscch......"<br />
end<br />
end<br />
<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => "quieeeetscch......"<br />
<br />
</source><br />
class_eval evaluiert einen übergebenen Block oder String im Klassenkontext. <br />
<br />
<br />
<source lang="ruby"><br />
Auto.class_eval <<-END<br />
def bremsen; "quieetsch....."; end;<br />
END<br />
</source><br />
class_eval mit übergebenen String<br />
<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12915Ruby (Programmiersprache)2009-07-09T10:08:57Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[Ruby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Prardigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer und sogar Klassen werden als Objekte behandelt. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Mixins: Module können in Klassen "eingemischt" werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
# Hier wird nur dem Objekt a eine Methode hinzugefügt<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
Metaprogrammierung mit class_eval<br />
<source lang="ruby"><br />
<br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
# Ab sofort gibt es für Auto-Klassen auch eine bremsen-Methode<br />
Auto.class_eval do<br />
def bremsen<br />
"quieeeetscch......"<br />
end<br />
end<br />
<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => "quieeeetscch......"<br />
<br />
</source><br />
class_eval evaluiert einen übergebenen Block oder String im Klassenkontext. <br />
<br />
<br />
<source lang="ruby"><br />
Auto.class_eval <<-END<br />
def bremsen; "quieetsch....."; end;<br />
END<br />
</source><br />
class_eval mit übergebenen String<br />
<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12914Ruby (Programmiersprache)2009-07-09T10:03:42Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[Ruby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Prardigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer und sogar Klassen werden als Objekte behandelt. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Mixins: Module könne in Klassen "eingemischt" werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
# Die Klasse Auto wird geöffnet und die Methode gas_geben neu definiert<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
# Hier wird nur dem Objekt a eine Methode hinzugefügt<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
Metaprogrammierung mit class_eval<br />
<source lang="ruby"><br />
<br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
# Ab sofort gibt es für Auto-Klassen auch eine bremsen-Methode<br />
Auto.class_eval do<br />
def bremsen<br />
"quieeeetscch......"<br />
end<br />
end<br />
<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => "quieeeetscch......"<br />
<br />
<br />
<br />
<br />
</source><br />
class_eval evaluiert einen String oder übergebenen Block im Klassenkontext. <br />
<br />
<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12913Ruby (Programmiersprache)2009-07-09T09:44:19Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[Ruby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Prardigma: Alle Datentypen sind Objekte, auch primitive Datentypen wie Integer und sogar Klassen werden als Objekte behandelt. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung, Klassenerweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
a = Auto.new<br />
puts a.gas_geben # => "noch schneller gas geben"<br />
</source><br />
<br />
<br />
Metaprogrammierung, Objekterweiterung:<br />
<br />
<source lang="ruby"><br />
class Auto<br />
def gas_geben<br />
"gas geben"<br />
end<br />
end<br />
<br />
class Auto<br />
def gas_geben<br />
"noch schneller gas geben" <br />
end<br />
end<br />
<br />
<br />
a = Auto.new<br />
<br />
class << a<br />
def bremsen<br />
"bremsen..."<br />
end<br />
end<br />
<br />
puts a.bremsen # => "bremsen..."<br />
puts Auto.new.bremsen # => noMethodError<br />
</source><br />
<br />
<br />
<br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12912Ruby (Programmiersprache)2009-07-09T09:34:39Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[Ruby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Prardigma: Alle Datentypen sind Objekte! Auch primitive Datentypen wie Integer oder sogar Klassen sind Objekte. <br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung: Klassen und Objekte können zur Laufzeit "geöffnet" und Methoden hinzugefügt oder verändert werden. <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung:<br />
<br />
<source lang="ruby"><br />
<br />
</source><br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Ruby_(Programmiersprache)&diff=12911Ruby (Programmiersprache)2009-07-09T09:33:53Z<p>Thoefer: </p>
<hr />
<div>= Definition =<br />
Ruby ist eine objektorientierte Skriptsprache, die Syntaxelemente von Perl mit Features von Smalltalk kombiniert.<br />
<br />
=Geschichte=<br />
Ruby wurde in Japan von Yukihiro "Matz" Matsumoto entwickelt und 1995 in der ersten Version veröffentlicht. <br />
<br />
=Interpreter=<br />
Abgesehen vom Original-Interpreter MRI (Matz-Ruby-Interpreter) gibt es inzwischen Portierungen für Java ([[JRuby]]) oder .NET (IronRuby). Damit lassen sich mit Ruby alle Klassen und Bibliotheken der zugrunde liegenden Plattform verwenden. <br />
<br />
=Integration=<br />
Die Integration von [[JRuby]] geht sogar so weit, dass sich mit [[Ruby on Rails]] JEE-konforme Webanwendungen entwickeln lassen, die man in einem JEE-Container deployen kann. Noch bessere Bytecode-Kompatibilität für Java bietet [[Groovy]]. <br />
<br />
= Features =<br />
* plattformübergreifend verwendbar<br />
* strenges objektorientiertes Prardigma: Alle Datentypen sind Objekte (auch Primitive)<br />
* Unterstüzung von regulären Ausdrücken auf Sprachebene<br />
* Automatisches Garbage Collection<br />
* Metaprogrammierung <br />
* Packetmanager [[RubyGems]]<br />
<br />
= Ruby Shell =<br />
Bei jeder Ruby-Installation ist eine Shell enthalten.<br />
Die „irb“-Shell („Interactive Ruby“) kann verwendet werden, um schnell und einfach Ausdrücke zu testen.<br />
<br />
= Beispiele = <br />
<br />
Integer:<br />
<source lang="ruby"><br />
irb(main):001:0> n = 2 * 3 + 2<br />
=> 8<br />
irb(main):002:0> n.class<br />
=> Fixnum<br />
</source><br />
<br />
String:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0>n = "Hallo " * 3<br />
=> "Hallo Hallo Hallo"<br />
irb(main):002:0> n.class<br />
=> String<br />
irb(main):003:0> n[0,5]<br />
=> "Hallo<br />
</source><br />
<br />
Schleifen:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = 0<br />
=> 0<br />
irb(main):002:0> 1.upto(5) do |i| a = a + i end<br />
=> 1<br />
irb(main):003:0> a<br />
=> 15<br />
</source><br />
<br />
Listen und Iterator:<br />
<br />
<source lang="ruby"><br />
irb(main):001:0> a = [ "a", "b", 2, "z", "21" ]<br />
=> ["a", "b", 2, "z", "21"]<br />
irb(main):002:0> a.pop<br />
=> "21"<br />
irb(main):003:0> a<br />
=> ["a", "b", 2, "z"]<br />
irb(main):004:0> a.each do |c| puts c.class end<br />
String<br />
String<br />
Fixnum<br />
String<br />
=> ["a", "b", 2, "z"]<br />
</source><br />
<br />
<br />
<br />
Metaprogrammierung:<br />
<br />
<source lang="ruby"><br />
<br />
</source><br />
<br />
<br />
JRuby: Verwendung von Swing mit JRuby<br />
<source lang="ruby"><br />
require "java"<br />
frame = javax.swing.JFrame.new()<br />
frame.setSize 200, 200<br />
frame.add javax.swing.JLabel.new("hallo welt")<br />
frame.setVisible true<br />
</source><br />
<br />
<br />
= Quellen =<br />
*[http://www.ruby-lang.org/ Ruby-Website]<br />
* Armin Roehrl und Stefan Schmiedl (2004): Big in Japan. Linux-Magazin Sonderheft Scripting Edition, Linux New Media AG<br />
* [http://jruby.codehaus.org JRuby]<br />
* [http://groovy.codehaus.org Groovy]<br />
<br />
=Siehe auch=<br />
*http://www.rubyenterpriseedition.com/<br />
<br />
{{{{SITENAME}}-konformer Artikel}}<br />
{{Quellenangaben verbessern<br />
| Formatierung = true<br />
}}</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12900Stored Procedure2009-07-06T21:23:04Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* <b>Wiederverwendbarkeit:</b> Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* <b>Wartbarkeit:</b> Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* <b>Performance:</b> Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* <b>Sicherheit:</b> Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen in PostgreSQL =<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch andere "Procedural Languages" wie PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen wie z.B. Schleifen zurückgreifen kann. <br />
<br />
Bevor man eine Funktion in einer "Procedural Language" schreiben kann, muss diese "installiert" werden. <br />
<br />
Dazu verwendet man z.B. für PL/pgSQL folgende Anweisung: <br />
<br />
<source lang="sql"><br />
CREATE LANGUAGE plpgsql;<br />
</source><br />
<br />
<br />
=Implementierungs-Beispiel einer rekursiven Funktion in PostgreSQL=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann '''die Größe eines Ordners rekursiv bestimmt''' werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung aber als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang.html PostgreSQL Manual, Chapter 37, Procedural Languages]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang-install.html PostgreSQL Manual, Chapter 37, Installing Procedural Languages]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12893Stored Procedure2009-07-06T20:08:48Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Wiederverwendbarkeit: Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* Wartbarkeit: Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* Performance: Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* Sicherheit: Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen in PostgreSQL =<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch andere "Procedural Languages" wie PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen wie z.B. Schleifen zurückgreifen kann. <br />
<br />
Bevor man eine Funktion in einer "Procedural Language" schreiben kann, muss diese "installiert" werden. <br />
<br />
Dazu verwendet man z.B. für PL/pgSQL folgende Anweisung: <br />
<br />
<source lang="sql"><br />
CREATE LANGUAGE plpgsql;<br />
</source><br />
<br />
<br />
=Implementierungs-Beispiel einer rekursiven Funktion in PostgreSQL=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann '''die Größe eines Ordners rekursiv bestimmt''' werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung aber als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang.html PostgreSQL Manual, Chapter 37, Procedural Languages]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang-install.html PostgreSQL Manual, Chapter 37, Installing Procedural Languages]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12892Stored Procedure2009-07-06T20:06:27Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Wiederverwendbarkeit: Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* Wartbarkeit: Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* Performance: Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* Sicherheit: Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen in PostgreSQL =<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch andere "Procedural Languages" wie PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen wie z.B. Schleifen zurückgreifen kann. <br />
<br />
Bevor man eine Funktion in einer "Procedural Language" schreiben kann, muss diese "installiert" werden. <br />
<br />
Dazu verwendet man z.B. für PL/pgSQL folgende Anweisung: <br />
<br />
<source lang="sql"><br />
CREATE LANGUAGE plpgsql;<br />
</source><br />
<br />
<br />
=Implementierungs-Beispiel in PostgreSQL=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung aber als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang.html PostgreSQL Manual, Chapter 37, Procedural Languages]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang-install.html PostgreSQL Manual, Chapter 37, Installing Procedural Languages]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12891Stored Procedure2009-07-06T20:05:32Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Wiederverwendbarkeit: Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* Wartbarkeit: Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* Performance: Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* Sicherheit: Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen in PostgreSQL =<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch andere "Procedural Languages" wie PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen wie z.B. Schleifen zurückgreifen kann. <br />
<br />
Bevor man eine Funktion in einer "Procedural Language" schreiben kann, muss diese erst in jeder Datenbank, in der diese verwendet werden soll "installiert" werden. <br />
<br />
Dazu verwendet man z.B. für PL/pgsql folgende Anweisung: <br />
<br />
<source lang="sql"><br />
CREATE LANGUAGE plpgsql;<br />
</source><br />
<br />
<br />
=Implementierungs-Beispiel in PostgreSQL=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung aber als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang.html PostgreSQL Manual, Chapter 37, Procedural Languages]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang-install.html PostgreSQL Manual, Chapter 37, Installing Procedural Languages]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12890Stored Procedure2009-07-06T20:04:31Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Wiederverwendbarkeit: Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* Wartbarkeit: Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* Performance: Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* Sicherheit: Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen in PostgreSQL =<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch andere "Procedural Languages" wie PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
Bevor man eine Funktion in einer "Procedural Language" schreiben kann muss man dieser erst in jeder Datenbank, in der diese verwendet werden soll "installiert" werden. <br />
<br />
Dazu verwendet man z.B. für PL/pgsql folgende Anweisung: <br />
<br />
<source lang="sql"><br />
CREATE LANGUAGE plpgsql;<br />
</source><br />
<br />
<br />
=Implementierungs-Beispiel in PostgreSQL=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung aber als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang.html PostgreSQL Manual, Chapter 37, Procedural Languages]<br />
* [http://www.postgresql.org/docs/8.3/static/xplang-install.html PostgreSQL Manual, Chapter 37, Installing Procedural Languages]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12889Stored Procedure2009-07-06T19:58:48Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Wiederverwendbarkeit: Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* Wartbarkeit: Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* Performance: Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* Sicherheit: Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen in PostgreSQL =<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel in PostgreSQL=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung aber als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [[http://www.postgresql.org/docs/8.3/static/xplang.html]]<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12888Stored Procedure2009-07-06T19:58:29Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Wiederverwendbarkeit: Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* Wartbarkeit: Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* Performance: Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* Sicherheit: Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen in PostgreSQL =<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung aber als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [[http://www.postgresql.org/docs/8.3/static/xplang.html]]<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12887Stored Procedure2009-07-06T19:57:21Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Wiederverwendbarkeit: Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* Wartbarkeit: Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* Performance: Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* Sicherheit: Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen=<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung aber als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [[http://www.postgresql.org/docs/8.3/static/xplang.html]]<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12886Stored Procedure2009-07-06T19:56:16Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Wiederverwendbarkeit: Eine Funktion kann von verschiedenen Clients genutzt werden. Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. <br />
<br />
* Wartbarkeit: Änderungen müssen nur zentral an einer Stelle durchgeführt werden. <br />
<br />
* Performance: Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn, da jegliche Kommunikation mit dem Clientprogramm während der Rekursion entfällt. Erst das Ergebnis wird dann wieder zum Clientprogramm geschickt. <br />
<br />
* Sicherheit: Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
<br />
=Implementierungs-Sprachen=<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann - das heißt man legt letztendlich eine Baumstruktur in der Datenbank ab. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ (MediaFile oder MediaDirectory) von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
Mit der Funktion "calc_mediadirectory_size" kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert, was in dieser Beispielanwendung als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [[http://www.postgresql.org/docs/8.3/static/xplang.html]]<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12885Stored Procedure2009-07-06T19:49:00Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die Datenbank geschickt werden. <br />
<br />
* Eine Funktion kann von verschiedenen Clients genutzt werden (Wiederverwendbarkeit). Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. Eine Änderung muss auch nur an einer Stelle durchgeführt werden (Wartbarkeit). <br />
<br />
* Vermeidung unnötiger Roundtrips zwischen Clientprogramm und Datenbank-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn. <br />
<br />
<br />
=Implementierungs-Sprachen=<br />
In [[Postgresql]] können neben reinem [[SQL]] auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel=<br />
Es soll ein [[Dateisystem]] in einer Datenbank modelliert werden, dh. eine Baumstruktur. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
<br />
Mit dieser Funktion kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente [[NULL]] liefert - was in dieser Beispielanwendung als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
* [[http://www.postgresql.org/docs/8.3/static/xplang.html]]<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12884Stored Procedure2009-07-06T19:42:47Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
[[Stored Procedure]]s sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Absicherung gegen [[SQL Injection]], da die [[Stored Procedure]]s zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die DB geschickt werden. <br />
<br />
* Eine Funktion kann von verschiedenen Clients genutzt werden (Wiederverwendbarkeit). Die [[SQL]]-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. Eine Änderung muss auch nur an einer Stelle durchgeführt werden (Wartbarkeit). <br />
<br />
* Vermeidung unnötiger Roundtrips zwischen Clientprogramm und DB-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn. <br />
<br />
<br />
=Implementierungssprachen=<br />
In [[Postgresql]] können neben reinem SQL auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel=<br />
Es soll ein Dateisystem in einer Datenbank abgelegt werden, dh. eine Baumstruktur. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
<br />
Mit dieser Funktion kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente NULL liefert - was in dieser Beispielanwendung als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12883Stored Procedure2009-07-06T19:31:00Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
Stored Procedures sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Absicherung gegen [[SQL Injection]], da die Stored Procedures zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die DB geschickt werden. <br />
<br />
* Eine Funktion kann von verschiedenen Clients genutzt werden (Wiederverwendbarkeit). Die SQL-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. Eine Änderung muss auch nur an einer Stelle durchgeführt werden (Wartbarkeit). <br />
<br />
* Vermeidung unnötiger Roundtrips zwischen Clientprogramm und DB-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn. <br />
<br />
<br />
=Implementierungssprachen=<br />
In [[Postgresql]] können neben reinem SQL auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel=<br />
Es soll ein Dateisystem in einer Datenbank abgelegt werden, dh. eine Baumstruktur. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
<br />
Mit dieser Funktion kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente NULL liefert - was in dieser Beispielanwendung als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
Aufruf der Funktion:<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12882Stored Procedure2009-07-06T19:29:49Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s (DBMS) möglich, komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit auszuführen. <br />
<br />
Stored Procedures sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Absicherung gegen [[SQL Injection]], da die Stored Procedures zusätzliche Befehle zur Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die DB geschickt werden. <br />
<br />
* Eine Funktion kann von verschiedenen Clients genutzt werden (Wiederverwendbarkeit). Die SQL-Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. Eine Änderung muss auch nur an einer Stelle durchgeführt werden (Wartbarkeit). <br />
<br />
* Vermeidung unnötiger Roundtrips zwischen Clientprogramm und DB-Server, da z.B. eine Rekursion vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender Performancegewinn. <br />
<br />
<br />
=Implementierungssprachen=<br />
In [[Postgresql]] können neben reinem SQL auch andere Sprache für das Schreiben von SP´s genutzt werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel=<br />
Es soll ein Dateisystem in einer Datenbank abgelegt werden, dh. eine Baumstruktur. Ein Knoten kann also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann. Ein Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt um welchen Typ von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
<br />
Mit dieser Funktion kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente NULL liefert - was in dieser Beispielanwendung als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoeferhttps://glossar.hs-augsburg.de/w/index.php?title=Stored_Procedure&diff=12881Stored Procedure2009-07-06T19:25:15Z<p>Thoefer: </p>
<hr />
<div>=Definition=<br />
<br />
Mit Hilfe von [[Stored Procedure]]s ist es dem Benutzer eines [[Datenbank-Management-System]]s <br />
<br />
(DBMS) möglich,<br />
komplexe Folgen von [[SQL]]-Anweisungen im System unter einem Namen zu speichern und jederzeit <br />
<br />
auszuführen. <br />
<br />
Stored Procedures sind Funktionen, die innerhalb des DB-Server gespeichert werden und wie alle <br />
<br />
anderen, bereits eingebauten Funktionen z.B. round() aufgerufen werden können. <br />
<br />
<br />
=Vorteile=<br />
<br />
* Absicherung gegen [[SQL Injection]], da die Stored Procedures zusätzliche Befehle zur <br />
<br />
Ablaufsteuerung und Auswertung erfolgter Anweisungen enthalten können. Noch besser ist es aber SQL <br />
<br />
Injection bereits auf Anwendungs-Ebene vorzubeugen, also bevor die Abfragen an die DB geschickt <br />
<br />
werden. <br />
<br />
* Eine Funktion kann von verschiedenen Clients genutzt werden (Wiederverwendbarkeit). Die SQL-<br />
<br />
Anweisung verbirgt sich in der Funktion uns muss nicht jedesmal neu formuliert werden. Eine <br />
<br />
Änderung muss auch nur an einer Stelle durchgeführt werden (Wartbarkeit). <br />
<br />
* Vermeidung unnötiger Roundtrips zwischen Clientprogramm und DB-Server, da z.B. eine Rekursion <br />
<br />
vollständig in der SP formuliert werden kann. Dadurch ergibt sich unter Umständen ein gravierender <br />
<br />
Performancegewinn. <br />
<br />
<br />
=Implementierungssprachen=<br />
In [[Postgresql]] können neben reinem SQL auch andere Sprache für das Schreiben von SP´s genutzt <br />
<br />
werden, z.B. in der Version 8.3: PL/pgSQL, eine PostgreSQL-eigene Sprache für das Schreiben von SP<br />
<br />
´s, aber auch PL/Tcl, PL/Python, PL/Perl oder C. <br />
<br />
Vorteil dieser Sprachen ist, dass man auf gewohnte Kontrollstrukturen zurückgreifen kann die es in <br />
<br />
reinem SQL nicht gibt z.B. Schleifen. <br />
<br />
<br />
=Implementierungs-Beispiel=<br />
Es soll ein Dateisystem in einer Datenbank abgelegt werden, dh. eine Baumstruktur. Ein Knoten kann <br />
<br />
also eine Datei oder ein Verzeichnis sein, welches wiederrum Kind-Elemente enthalten kann. Ein <br />
<br />
Problem in einer solchen Anwendung ist es, die Größe eines Ordners zu ermittteln. <br />
<br />
Im folgenden entspricht eine Datei einem MediaFile, ein Verzeichnis einem MediaDirectory. MediaFile <br />
<br />
und MediaDirectory sind beides MediaItems (Ist-Ein-Beziehung). Im Attribut parent_id ist der <br />
<br />
jeweilige Ordner referenziert in dem sich ein MediaItem befindet. Im Attribut type ist hinterlegt <br />
<br />
um welchen Typ von MediaItem es sich handelt. <br />
<br />
Vereinfachtes Datenbank-Schema:<br />
<source lang="sql"><br />
CREATE TABLE media_items<br />
(<br />
id INTEGER NOT NULL, <br />
parent_id INTEGER, <br />
type VARCHAR(80) NOT NULL, <br />
name VARCHAR(80) NOT NULL, <br />
size INTEGER, <br />
content BYTEA,<br />
);<br />
</source><br />
<br />
<br />
<br />
Mit dieser Funktion kann die Größe eines Ordners rekursiv bestimmt werden. Die Verwendung der <br />
<br />
coalesce-Funktion ist notwendig da ein MediaDirectory ohne Kind-Elemente NULL liefert - was in <br />
<br />
dieser Beispielanwendung als 0 interpretiert werden soll. <br />
<source lang="sql"><br />
CREATE FUNCTION calc_mediadirectory_size(integer) RETURNS numeric AS $$<br />
SELECT coalesce(sum(s), 0)<br />
FROM (<br />
SELECT<br />
CASE <br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END<br />
FROM media_items WHERE parent_id = $1<br />
) sizetab(s)<br />
$$ LANGUAGE SQL;<br />
</source><br />
<br />
<br />
<br />
<source lang="sql"><br />
SELECT<br />
CASE<br />
WHEN type = 'MediaDirectory' THEN<br />
calc_mediadirectory_size(id)<br />
WHEN type = 'MediaFile' THEN<br />
size<br />
END AS size, name<br />
FROM<br />
media_items<br />
</source><br />
<br />
<br />
<br />
=Quellen=<br />
<br />
* [[Ziegler (2007)]]<br />
* [[Rütten, Glemser (2006)]]<br />
<br />
=Siehe auch=<br />
<br />
*[[Prepared Statement]]<br><br />
*[[SQL Injection]]<br />
<br />
[[Kategorie:Daten-Management]]<br />
[[Kategorie:Sicherheit]]<br />
[[Kategorie:Glossar]]</div>Thoefer