Neo-Nevz

How do I convert array into JSON?

2012-11-07T16:25:00.003+07:00

Date: 2010-09-16. Category: com.google.gson examples. Hits: 12K time(s).

In the example below you can see how to convert an array into JSON string. We serialize the array to JSON using the Gson.toJson() method. To deserialize a string of JSON into array we use the Gson.fromJson() method.

package org.kodejava.example.google.gson;

import com.google.gson.Gson;

public class ArrayToJson {

    public static void main(String[] args) {

        int[] numbers = {1, 1, 2, 3, 5, 8, 13};

        String[] days = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};

        //

        // Create a new instance of Gson

        //

        Gson gson = new Gson();

        //

        // Convert numbers array into JSON string.

        //

        String numbersJson = gson.toJson(numbers);

        //

        // Convert strings array into JSON string

        //

        String daysJson = gson.toJson(days);

        System.out.println("numbersJson = " + numbersJson);

        System.out.println("daysJson = " + daysJson);

        //

        // Convert from JSON string to a primitive array of int.

        //

        int[] fibonacci = gson.fromJson(numbersJson, int[].class);

        for (int i = 0; i < fibonacci.length; i++) {

            System.out.print(fibonacci[i] + " ");

        }

        System.out.println("");

        //

        // Convert from JSON string to a string array.

        //

        String[] weekDays = gson.fromJson(daysJson, String[].class);

        for (int i = 0; i < weekDays.length; i++) {

            System.out.print(weekDays[i] + " ");

        }

        System.out.println("");

        //

        // Converting multidimensional array into JSON

        //

        int[][] data = {{1, 2, 3}, {3, 4, 5}, {4, 5, 6}};

        String json = gson.toJson(data);

        System.out.println("Data = " + json);

        //

        // Convert JSON string into multidimensional array of int.

        //

        int[][] dataMap = gson.fromJson(json, int[][].class);

        for (int i = 0; i < data.length; i++) {

            for (int j = 0; j < data[i].length; j++) {

                System.out.print(data[i][j] + " ");

            }

            System.out.println("");

        }

    }

}

XML ERROR

2012-07-09T13:32:00.001+07:00

XML Parsing Error: not well-formed

Answer :
http://stackoverflow.com/questions/4267244/xml-parsing-error-not-well-formed?rq=1

JAVA StringWriter

2012-07-06T17:10:00.000+07:00

http://www.codingdiary.com/developers/developers/diary/javaapi/java/io/SampleCode/StringWriterWriteExampleCode.html

Java StringWriter write() Example

StringWriter class write() method example. This example shows you how to use write() method.
Syntax is : public void write(char[] cbuf, int off, int len)
This method writes a subArray of specified array to StringWriter buffer.

Here is the code.

 /**

             * @(#) WriteStringWriter.java

             * A class representing use of method write() of StringWriter class in 

             java.io Package.

             * @Version  29-May-2008

             * @author   Rose India Team

             */

            import java.io.*;

            public class WriteStringWriter {

                 public static void main(String[] args){

            

                     char arrChar[] = {' ','P','v','t','.',' ','i','n','d','i','a'};

                // Create object of StringWriter class

                    StringWriter obj = new StringWriter();

                    // append() method call.

                    obj.append("Rose ");

                obj.append("India");

                    System.out.println("String in string buffer is : " + obj);

                // write() method call.

                obj.write(arrChar,0,5);

                System.out.println("After writing a sub array StringBuffer is : "+obj);

                }

            }

Output of the program.

String in string buffer is : Rose India
After writing a sub array StringBuffer is : Rose India Pvt.

ARRAY LIST IN JAVA

2012-07-06T15:05:00.002+07:00

http://www.java-samples.com/showtutorial.php?tutorialid=234

The ArrayList class extends AbstractList and implements the List interface. ArrayList supports dynamic arrays that can grow as needed. In Java, standard arrays are of a fixed length. After arrays are created, they cannot grow or shrink, which means that you must know in advance how many elements an array will hold. But, sometimes, you may not know until run time precisely how large of an array you need. To handle this situation, the collections framework defines ArrayList. In essence, an ArrayList is a variable-length array of object references. That is, an ArrayList can dynamically increase or decrease in size. Array lists are created with an initial size. When this size is exceeded, the collection is automatically enlarged. When objects are removed, the array may be shrunk.
ArrayList has the constructors shown here:

ArrayList( )

ArrayList(Collection c)

ArrayList(int capacity)

The first constructor builds an empty array list. The second constructor builds an array list that is initialized with the elements of the collection c. The third constructor builds an array list that has the specified initial capacity. The capacity is the size of the underlying array that is used to store the elements. The capacity grows automatically as elements are added to an array list.
The following program shows a simple use of ArrayList. An array list is created, and then objects of type String are added to it. (Recall that a quoted string is translated into a String object.) The list is then displayed. Some of the elements are removed and the list is displayed again.

// Demonstrate ArrayList.

import java.util.*;

class ArrayListDemo {

public static void main(String args[]) {

// create an array list

ArrayList al = new ArrayList();

System.out.println("Initial size of al: " +

al.size());

// add elements to the array list

al.add("C");

al.add("A");

al.add("E");

al.add("B");

al.add("D");

al.add("F");

al.add(1, "A2");

System.out.println("Size of al after additions: " +

al.size());

// display the array list

System.out.println("Contents of al: " + al);

// Remove elements from the array list

al.remove("F");

al.remove(2);

System.out.println("Size of al after deletions: " +

al.size());

System.out.println("Contents of al: " + al);

}

}

The output from this program is shown here:

Initial size of al: 0

Size of al after additions: 7

Contents of al: [C, A2, A, E, B, D, F]

Size of al after deletions: 5

Contents of al: [C, A2, E, B, D]

Notice that a1 starts out empty and grows as elements are added to it. When elements are removed, its size is reduced.
Although the capacity of an ArrayList object increases automatically as objects are stored in it, you can increase the capacity of an ArrayList object manually by calling ensureCapacity( ). You might want to do this if you know in advance that you will be storing many more items in the collection that it can currently hold. By increasing its capacity once, at the start, you can prevent several reallocations later. Because reallocations are costly in terms of time, preventing unnecessary ones improves performance. The signature for ensureCapacity( ) is shown here:
void ensureCapacity(int cap)
Here, cap is the new capacity. Conversely, if you want to reduce the size of the array that underlies an ArrayList object so that it is precisely as large as the number of items that it is currently holding, call
trimToSize( ), shown here:
void trimToSize( ) Obtaining an Array from an ArrayList
When working with ArrayList, you will sometimes want to obtain an actual array that contains the contents of the list. As explained earlier, you can do this by calling toArray( ). Several reasons exist why you might want to convert a collection into an array such as:
• To obtain faster processing times for certain operations.
• To pass an array to a method that is not overloaded to accept a collection.
• To integrate your newer, collection-based code with legacy code that does not understand collections.
Whatever the reason, converting an ArrayList to an array is a trivial matter, as the following program shows:

// get array

Object ia[] = al.toArray();

int sum = 0;

// sum the array

for(int i=0; i<ia.length; i++)

sum += ((Integer) ia[i]).intValue();

System.out.println("Sum is: " + sum);

}

}

The output from the program is shown here:

Contents of al: [1, 2, 3, 4]

Sum is: 10

The program begins by creating a collection of integers. As explained, you cannot store primitive types in a collection, so objects of type Integer are created and stored. Next, toArray( ) is called and it obtains an array of Objects. The contents of this array are cast to Integer, and then the values are summed.

CONNECT SSH IN PHP

2012-07-04T11:27:00.005+07:00

http://dendieisme.blogspot.com/2010/09/connect-ssh-with-php.html

Secara default PHP tidak menyertakan library untuk melakukak SSH. Pada posting ini akan coba dijelasakan untuk melakukan Connection SSH melalui PHP.

Spesifikasi komputer pada posting ini adalah :

Operating System Linux Ubuntu Lucid Lynx
PHP version 5.3.2

Agar PHP dapat melakukan SSH membutuhkan sebuah library. Library tersebut adalah PHP Secure Communications Library atau biasa di singkat phpseclib

phpseclib adalah sebuah library PHP untuk melakukan berbagai komunikasi melalui SSH, SFTP, Aritmatika Presisi dan berbagai macam Kriptografi. Berikut ini adalah cara menggunakan libary phpseclib untuk SSH.

Download library phpseclib di http://phpseclib.sourceforge.net/
Ekstrak phpseclib0.2.1a.zip di www root/public html web server Anda.
Kemudian buat sebuah file pada folder hasil ekstrak phpseclib0.2.1a.zip lalu sebagi contoh ketikan perintah seperti dibawah ini

view plain print ?

<?php
include('Net/SSH2.php');
$ssh = new Net_SSH2('127.0.0.1');
if (!$ssh->login('dendie', 'xxx')) {
exit('Login Failed');
}
echo $ssh->exec('ls');
?>

Pada contoh diatas malakukan connection ssh ke komputer 127.0.0.1 dengan username name dendie dan password xxx Dan $ssh->exec('pwd') adalah perintah command line linux untuk mendapatkan alamat path aktif berada. Hasil perintah di atas adalah sebagai berikut

view plain print ?

/home/dendie

Sebagai Contoh dalam pengembangan selanjutnya Connection SSH melalui PHP dapat dikembangkan untuk melakukan monitoring kapasitas harddisk, CPU Usage, Memori Usage dsb, secara bersamaan dan secara remote kebanyak komputer/server, kemudian hasilnya ditampilkan pada web-page, seperti contoh dibawah ini:

Untuk mempermudah melakukan monitoring serprti di atas dapat menggunakan class actServer, silakan download di klik download

Berikut ini adalah cara menggunakan-nya:

view plain print ?

include('actServer.php')
error_reporting(0);
$act = new actServerClass();
$act->setServer('127.0.0.1','username','password');
echo $act->getCpuUsePer(). ' %'; //CPU Active processes dalam persen
echo act->getMemUsePer(). ' %'; //Memori Active processes dalam persen
echo $act->getMemUse(); //Memori Usage (megabyte)
echo $act->getSpace(); //Harddisk Space
echo $act->getDetail('mem'); //Detail Active processes Memori
echo $act->getDetail('cpu'); //Detail Active processes CPU
$act->setflush()

NGINX

2012-07-03T17:20:00.001+07:00

http://blog.s13epy.web.id/instalasi-nginx.html

Apa sih nginx? Nginx adalah webserver sama seperti Apache dan Lighttpd, mungkin bedanya seperti yang saya cari di paman google, klo nginx banyak yang bilang lebih powerfull n lebih cepet, dibandingkan dengan Apache ataupun Lighttpd.
Disini saya akan melakukan instalasi Nginx di LinuxMint 8 (Helena) yang merupakan turunan dari ubuntu 9.10 (Karmic Koala).
Yang pertama kita Instalasi Nginx terlebih dahulu

sudo apt-get install nginx

atau bila kita ingin menggunakan source code

sudo wget http://sysoev.ru/nginx/nginx-0.6.36.tar.gz
tar -xzvf nginx-0.6.36.tar.gz
cd nginx-0.6.36.tar.gz
sudo apt-get install build-essential
./configure
make
sudo make install

untuk settingan di ubuntu ataupun turunannya

./configure –conf-path=/etc/nginx/nginx.conf \
–error-log-path=/var/log/nginx/error.log –pid-path=/var/run/nginx.pid \
–lock-path=/var/lock/nginx.lock –http-log-path=/var/log/nginx/access.log \
–http-client-body-temp-path=/var/lib/nginx/body –http-proxy-temp-path=/var/lib/nginx/proxy \
–http-fastcgi-temp-path=/var/lib/nginx/fastcgi –with-debug –with-http_stub_status_module \
–with-http_flv_module –with-http_ssl_module –with-http_dav_module
make
sudo make install

Setelah itu jalankan nginx

sudo /etc/init.d/nginx start

Agar setiap booting nginx dapat langsung berjalan

sudo update-rc.d nginx defaults

Untuk melihat apakah nginx telah berjalan ketikkan localhost pada browser.
Selanjutnya kita install paket php

sudo apt-get install php5-cgi php5-mysql php5-curl php5-gd php5-idn php-pear php5-imagick php5-imap php5-mcrypt php5-memcache php5-mhash php5-ming php5-pspell php5-recode php5-snmp php5-sqlite php5-tidy php5-xmlrpc php5-xsl
kemudian edit file /etc/php5/cgi/php.ini
sudo gedit /etc/php5/cgi/php.ini

Ubah cgi.fix_pathinfo = 0 menjadi 1

[...]
cgi.fix_pathinfo = 1

Kemudian install

sudo apt-get install spawn-fcgi

gunakan perintah berikut untuk menjalankan php cgi

sudo /usr/bin/spawn-fcgi -a 127.0.0.1 -p 9000 -u www-data -g www-data -f /usr/bin/php5-cgi -P /var/run/fastcgi-php.pid

tambahkan perintah di pada /etc/rc.local

[...]
/usr/bin/spawn-fcgi -a 127.0.0.1 -p 9000 -u www-data -g www-data -f /usr/bin/php5-cgi -P /var/run/fastcgi-php.pid
[...]

edit file nginx.conf

sudo gedit /etc/nginx/nginx.conf

edit bagian berikut

[...]
worker_processes 5;
[...]
keepalive_timeout 2;
[...]

Selajutnya mengubah path file default sesuai keinginan kita

sudo gedit /etc/nginx/sites-available/default

[...]
server {
listen 80;
server_name localhost;

access_log /var/log/nginx/localhost.access.log;

location / {
#root /var/www/nginx-default;
root /home/vq/public_html;
index index.php index.html index.htm;
}

location /doc {
root /usr/share;
autoindex on;
allow 127.0.0.1;
deny all;
}

location /images {
root /usr/share;
autoindex on;
}

#error_page 404 /404.html;

# redirect server error pages to the static page /50x.html
#
error_page 500 502 503 504 /50x.html;
location = /50x.html {
#root /var/www/nginx-default;
root /home/vq/public_html;
}

# proxy the PHP scripts to Apache listening on 127.0.0.1:80
#
#location ~ \.php$ {
#proxy_pass http://127.0.0.1;
#}

# pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
#
location ~ \.php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /home/vq/public_html$fastcgi_script_name;
include fastcgi_params;
}

# deny access to .htaccess files, if Apache’s document root
# concurs with nginx’s one
#
location ~ /\.ht {
deny all;
}
}
[...]

Terakhir kita tinggal melakukan restart nginx

sudo /etc/init.d/nginx restart

Untuk melihat apakah php-nya sudah berjalan

sudo gedit /home/vq/public_html/info.php

isi file info.php dengan kode berikut

Login Logout CodeIgniter

2012-07-01T03:35:00.003+07:00

http://www.codefactorycr.com/login-with-codeigniter-php.html

Simple Login with CodeIgniter in PHP

Apr 18, 2011 // by aarias // Blog, PHP // No Comments

CodeIgniter is an open source Web Application framework built in PHP designed to make your life as a programmer easier, while allowing you good speed for development, and also good performance when the site is up and running.
Being a Java developer for almost 10 years now, when I had to move to PHP I chose CodeIgniter for the following reasons:

Easy to install and configure (being a newbie in PHP this was crucial)
Clean and elegant MVC implementation
Uses Active Record pattern for database access
Overall small footprint and good performance

Usually when you are building a program, the login/logout functionality is a must we always have to go through, so this quick tutorial will focus on this functionality, taking advantage of the benefits of using CodeIgniter instead of doing it from scratch in PHP.

Requirements

CodeIgniter framework. By the time this tutorial was done, the latest version was 2.0.2
Any Apache/PHP/MySQL stack. You can install the applications independently, or install one of those packages that have all of them bundled together.

Installing CodeIgniter

To install CodeIgniter, you only need to uncompress the Zip file you download from the site into your htdocs directory and you’re good to go. We’ll configure the database access later.

Create the database

For this tutorial, you need a MySQL database with the following table:

1CREATE TABLE `users` (

2 `id` tinyint(4) NOT NULL AUTO_INCREMENT,

3 `username` varchar(10) NOT NULL,

4 `password` varchar(100) NOT NULL,

5 PRIMARY KEY (`id`)

6) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Remember also to add at least one user. We’ll add one user called bob with password supersecret.

`1`	`insert` `into` `users (username,` `password)` `values` `('bob', MD5('supersecret'));`

Configure CodeIgniter

Database Access

Update the file application/config/database.php in your CodeIgniter installation with your database info:

44$db['default']['hostname'] = 'localhost';

45$db['default']['username'] = 'yourdbusername';

46$db['default']['password'] = 'yourdbpassword';

47$db['default']['database'] = 'yourdbname';

Default Controller

We need to tell CodeIgniter to land into our login page instead of the default welcome page. Update the file application/config/routes.php in your CodeIgniter installation with you controller’s name. We’ll call our landing controller login.

`41`	`$route['default_controller'] =` `"login";`

Default Libraries

In the file application/config/autoload.php you can configure the default libraries you want to load in all your controllers. For our case, we’ll load the database and session libraries, since we want to handle user sessions, and also the URL helper for internal link generation

`55`	`$autoload['libraries'] =` `array('database','session');`

`67`	`$autoload['helper'] =` `array('url');`

Encryption Key

When you use the session library, you need to set the encryption_key in the file application/config/config.php.

227 $config['encryption_key'] = 'REALLY_LONG_NUMBER';

The Code

Here are the actual Views, Controllers and Model we are using for the login functionality.

User Model (application/models/user/php)

1<?php

2Class User extends CI_Model

3{

4 function login($username, $password)

5 {

6   $this -> db -> select('id, username, password');

7   $this -> db -> from('users');

8   $this -> db -> where('username = ' . "'" . $username . "'");

9   $this -> db -> where('password = ' . "'" . MD5($password) . "'");

10   $this -> db -> limit(1);

11 

12   $query = $this -> db -> get();

13 

14   if($query -> num_rows() == 1)

15   {

16     return $query->result();

17   }

18   else

19   {

20     return false;

21   }

22 }

23}

24?>

Login Controller (application/controllers/login.php)

1<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

2 

3class Login extends CI_Controller {

4 

5 function __construct()

6 {

7   parent::__construct();

8 }

9 

10 function index()

11 {

12   $this->load->helper(array('form', 'url'));

13   $this->load->view('login_view');

14 }

15 

16}

17 

18?>

Login View (application/views/login_view.php)

1<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

2<html xmlns="http://www.w3.org/1999/xhtml">

3 <head>

4   <title>Simple Login with CodeIgniter</title>

5 </head>

6 <body>

7   <h1>Simple Login with CodeIgniter</h1>

8   <?php echo validation_errors(); ?>

9   <?php echo form_open('verifylogin'); ?>

10     <label for="username">Username:</label>

11     <input type="text" size="20" id="username" name="username"/>

12     <br/>

13     <label for="password">Password:</label>

14     <input type="password" size="20" id="passowrd" name="password"/>

15     <br/>

16     <input type="submit" value="Login"/>

17   </form>

18 </body>

19</html>

VerifyLogin Controller (application/controllers/verifylogin.php)

This controller does the actual validation of the fields and checks the credentials against the database.

1<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

2 

3class VerifyLogin extends CI_Controller {

4 

5 function __construct()

6 {

7   parent::__construct();

8   $this->load->model('user','',TRUE);

9 }

10 

11 function index()

12 {

13   //This method will have the credentials validation

14   $this->load->library('form_validation');

15 

16   $this->form_validation->set_rules('username', 'Username', 'trim|required|xss_clean');

17   $this->form_validation->set_rules('password', 'Password', 'trim|required|xss_clean|callback_check_database');

18 

19   if($this->form_validation->run() == FALSE)

20   {

21     //Field validation failed.  User redirected to login page

22     $this->load->view('login_view');

23   }

24   else

25   {

26     //Go to private area

27     redirect('home', 'refresh');

28   }

29 

30 }

31 

32 function check_database($password)

33 {

34   //Field validation succeeded.  Validate against database

35   $username = $this->input->post('username');

36 

37   //query the database

38   $result = $this->user->login($username, $password);

39 

40   if($result)

41   {

42     $sess_array = array();

43     foreach($result as $row)

44     {

45       $sess_array = array(

46         'id' => $row->id,

47         'username' => $row->username

48       );

49       $this->session->set_userdata('logged_in', $sess_array);

50     }

51     return TRUE;

52   }

53   else

54   {

55     $this->form_validation->set_message('check_database', 'Invalid username or password');

56     return false;

57   }

58 }

59}

60?>

Home Controller (application/controllers/home.php)

This is the private page (only authenticated users can access it).

1<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

2session_start(); //we need to call PHP's session object to access it through CI

3class Home extends CI_Controller {

4 

5 function __construct()

6 {

7   parent::__construct();

8 }

9 

10 function index()

11 {

12   if($this->session->userdata('logged_in'))

13   {

14     $session_data = $this->session->userdata('logged_in');

15     $data['username'] = $session_data['username'];

16     $this->load->view('home_view', $data);

17   }

18   else

19   {

20     //If no session, redirect to login page

21     redirect('login', 'refresh');

22   }

23 }

24 

25 function logout()

26 {

27   $this->session->unset_userdata('logged_in');

28   session_destroy();

29   redirect('home', 'refresh');

30 }

31 

32}

33 

34?>

Home Page View (application/views/home_view.php)

1<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

2<html xmlns="http://www.w3.org/1999/xhtml">

3 <head>

4   <title>Simple Login with CodeIgniter - Private Area</title>

5 </head>

6 <body>

7   <h1>Home</h1>

8   <h2>Welcome <?php echo $username; ?>!</h2>

9   <a href="home/logout">Logout</a>

10 </body>

11</html>

The code is pretty easy to follow and understand. Also, you can download the code from here, so you can install it and test it in your location. You’ll only need a full installation of CodeIgniter 2.0.2 and the table in your MySQL database. If you need any help, feel free to leave us a comment or shoot us an email.
Also, this code uses a pretty basic form validation from CodeIgniter. If you need a more complex validation process, check CodeIgniter’s Form Validation docs at their site.

REMOVE FILE OR DIRECTORY FROM CONSOLE LINUX

2012-06-28T11:53:00.001+07:00

Use the rmdir command. This command remove the DIRECTORY(ies), if they are empty. Open a command-line terminal (select Applications > Accessories > Terminal), and then type the following command to remove a directory called /tmp/docs:

 
rmdir /tmp/docs

If a directory is not empty you will get an error:
$ rmdir letters
Output:

rmdir: letters: Directory not empty

You can cd to the directory to find out files:

$ cd letters
 $ ls

Linux Remove Entire Directory Command

To remove all directories and subdirectories use rm command. For example remove letters and all subdirectories and files inside this directory, type the following command (warning all files including subdirectories will be deleted permanently):
$ rm -rf letters/

JAVA TRANSFORM XML FILE FROM SQL

2012-06-27T16:11:00.002+07:00

http://www.java2s.com/Code/Java/Database-SQL-JDBC/ConvertaResultSettoXML.htm

import java.io.StringWriter;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;



import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;



import org.w3c.dom.Document;

import org.w3c.dom.Element;



public class Main {



  public static void main(String args[]) throws Exception {

    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

    DocumentBuilder builder = factory.newDocumentBuilder();

    Document doc = builder.newDocument();

    Element results = doc.createElement("Results");

    doc.appendChild(results);



    Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

    Connection con = DriverManager

        .getConnection("jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=c:/access.mdb");

    

    ResultSet rs = con.createStatement().executeQuery("select * from product");



    ResultSetMetaData rsmd = rs.getMetaData();

    int colCount = rsmd.getColumnCount();



    while (rs.next()) {

      Element row = doc.createElement("Row");

      results.appendChild(row);

      for (int i = 1; i <= colCount; i++) {

        String columnName = rsmd.getColumnName(i);

        Object value = rs.getObject(i);

        Element node = doc.createElement(columnName);

        node.appendChild(doc.createTextNode(value.toString()));

        row.appendChild(node);

      }

    }

    DOMSource domSource = new DOMSource(doc);

    TransformerFactory tf = TransformerFactory.newInstance();

    Transformer transformer = tf.newTransformer();

    transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");

    transformer.setOutputProperty(OutputKeys.METHOD, "xml");

    transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

    StringWriter sw = new StringWriter();

    StreamResult sr = new StreamResult(sw);

    transformer.transform(domSource, sr);



    System.out.println(sw.toString());



    con.close();

    rs.close();

  }

}

GALAXYICS CAMERA

2012-06-22T16:03:00.002+07:00

http://maclaw.pl/?p=51

IT ISN’T PATCH MADE BY LAGLOOSE, IT’S MADE BY MY TEAM AND WE CAN RELEASE IT WHEN WE WANT!
Preview isn’t working, but everything else (like flash etc.) is working normally:
https://www.box.com/s/43b3687fbeda1155fd65
(Just apply in recovery)
If you must to share that patch, link not directly to them, but to this post.
Mirrors aren’t welcomed.
Enjoy

Copy Ant

2012-06-21T03:09:00.004+07:00

Copy

Description

Copies a file or resource collection to a new file or directory. By default, files are only copied if the source file is newer than the destination file, or when the destination file does not exist. However, you can explicitly overwrite files with the overwrite attribute.
Resource Collections are used to select a group of files to copy. To use a resource collection, the todir attribute must be set. Note that some resources (for example the file resource) return absolute paths as names and the result of using them without using a nested mapper (or the flatten attribute) may not be what you expect.
Note: If you employ filters in your copy operation, you should limit the copy to text files. Binary files will be corrupted by the copy operation. This applies whether the filters are implicitly defined by the filter task or explicitly provided to the copy operation as filtersets. See encoding note.

Parameters

Attribute	Description	Required
file	The file to copy.	Yes, unless a nested resource collection element is used.
preservelastmodified	Give the copied files the same last modified time as the original source files.	No; defaults to false.
tofile	The file to copy to.	With the `file` attribute, either `tofile` or `todir` can be used. With nested resource collection elements, if the number of included resources is greater than 1, or if only the `dir` attribute is specified in the `<fileset>`, or if the `file` attribute is also specified, then only `todir` is allowed. Prior to Apache Ant 1.8.2 the `tofile` attribute only supported filesystem resources top copy from.
todir	The directory to copy to.
overwrite	Overwrite existing files even if the destination files are newer.	No; defaults to false.
force	Overwrite read-only destination files. since Ant 1.8.2	No; defaults to false.
filtering	Indicates whether token filtering using the global build-file filters should take place during the copy. Note: Nested `<filterset>` elements will always be used, even if this attribute is not specified, or its value is `false` (`no`, or `off`).	No; defaults to false.
flatten	Ignore the directory structure of the source files, and copy all files into the directory specified by the `todir` attribute. Note that you can achieve the same effect by using a flatten mapper.	No; defaults to false.
includeEmptyDirs	Copy any empty directories included in the FileSet(s).	No; defaults to true.
failonerror	If false, log a warning message, but do not stop the build, when the file to copy does not exist or one of the nested filesets points to a directory that doesn't exist or an error occurs while copying.	No; defaults to true.
verbose	Log the files that are being copied.	No; defaults to false.
encoding	The encoding to assume when filter-copying the files. since Ant 1.5.	No - defaults to default JVM encoding
outputencoding	The encoding to use when writing the files. since Ant 1.6.	No - defaults to the value of the encoding attribute if given or the default JVM encoding otherwise.
enablemultiplemappings	If true the task will process to all the mappings for a given source path. If false the task will only process the first file or directory. This attribute is only relevant if there is a mapper subelement. since Ant 1.6.	No - defaults to false.
granularity	The number of milliseconds leeway to give before deciding a file is out of date. This is needed because not every file system supports tracking the last modified time to the millisecond level. Default is 1 second, or 2 seconds on DOS systems. This can also be useful if source and target files live on separate machines with clocks being out of sync. since Ant 1.6.2.	No

Parameters specified as nested elements

fileset or any other resource collection

Resource Collections are used to select groups of files to copy. To use a resource collection, the todir attribute must be set.
Prior to Ant 1.7 only <fileset> has been supported as a nested element.

mapper

You can define filename transformations by using a nested mapper element. The default mapper used by <copy> is the identity mapper.
Since Ant 1.6.3, one can use a filenamemapper type in place of the mapper element.
Note that the source name handed to the mapper depends on the resource collection you use. If you use <fileset> or any other collection that provides a base directory, the name passed to the mapper will be a relative filename, relative to the base directory. In any other case the absolute filename of the source will be used.

filterset

FilterSets are used to replace tokens in files that are copied. To use a FilterSet, use the nested <filterset> element.
It is possible to use more than one filterset.

filterchain

The Copy task supports nested FilterChains.
If <filterset> and <filterchain> elements are used inside the same <copy> task, all <filterchain> elements are processed first followed by <filterset> elements.

Examples

Copy a single file

  <copy file="myfile.txt" tofile="mycopy.txt"/>

Copy a single file to a directory

  <copy file="myfile.txt" todir="../some/other/dir"/>

Copy a directory to another directory

  <copy todir="../new/dir">
    <fileset dir="src_dir"/>
  </copy>

Copy a set of files to a directory

  <copy todir="../dest/dir">
    <fileset dir="src_dir">
      <exclude name="**/*.java"/>
    </fileset>
  </copy>

  <copy todir="../dest/dir">
    <fileset dir="src_dir" excludes="**/*.java"/>
  </copy>

Copy a set of files to a directory, appending .bak to the file name on the fly

  <copy todir="../backup/dir">
    <fileset dir="src_dir"/>
    <globmapper from="*" to="*.bak"/>
  </copy>

Copy a set of files to a directory, replacing @TITLE@ with Foo Bar in all files.

  <copy todir="../backup/dir">
    <fileset dir="src_dir"/>
    <filterset>
      <filter token="TITLE" value="Foo Bar"/>
    </filterset>
  </copy>

Collect all items from the current CLASSPATH setting into a destination directory, flattening the directory structure.

  <copy todir="dest" flatten="true">
    <path>
      <pathelement path="${java.class.path}"/>
    </path>
  </copy>

Copies some resources to a given directory.

  <copy todir="dest" flatten="true">
    <resources>
      <file file="src_dir/file1.txt"/>
      <url url="http://ant.apache.org/index.html"/>
    </resources>
  </copy>

If the example above didn't use the flatten attribute, the <file> resource would have returned its full path as source and target name and would not have been copied at all. In general it is a good practice to use an explicit mapper together with resources that use an absolute path as their names.
Copies the two newest resources into a destination directory.

  <copy todir="dest" flatten="true">
    <first count="2">
      <sort>
        <date xmlns="antlib:org.apache.tools.ant.types.resources.comparators"/>
        <resources>
          <file file="src_dir/file1.txt"/>
          <file file="src_dir/file2.txt"/>
          <file file="src_dir/file3.txt"/>
          <url url="http://ant.apache.org/index.html"/>
        </resources>
      </sort>
    </first>
  </copy>

The paragraph following the previous example applies to this example as well.
Unix Note: File permissions are not retained when files are copied; they end up with the default UMASK permissions instead. This is caused by the lack of any means to query or set file permissions in the current Java runtimes. If you need a permission-preserving copy function, use <exec executable="cp" ... > instead.
Windows Note: If you copy a file to a directory where that file already exists, but with different casing, the copied file takes on the case of the original. The workaround is to delete the file in the destination directory before you copy it.
Important Encoding Note: The reason that binary files when filtered get corrupted is that filtering involves reading in the file using a Reader class. This has an encoding specifing how files are encoded. There are a number of different types of encoding - UTF-8, UTF-16, Cp1252, ISO-8859-1, US-ASCII and (lots) others. On Windows the default character encoding is Cp1252, on Unix it is usually UTF-8. For both of these encoding there are illegal byte sequences (more in UTF-8 than for Cp1252).
How the Reader class deals with these illegal sequences is up to the implementation of the character decoder. The current Sun Java implemenation is to map them to legal characters. Previous Sun Java (1.3 and lower) threw a MalformedInputException. IBM Java 1.4 also thows this exception. It is the mapping of the characters that cause the corruption.
On Unix, where the default is normally UTF-8, this is a big problem, as it is easy to edit a file to contain non US Ascii characters from ISO-8859-1, for example the Danish oe character. When this is copied (with filtering) by Ant, the character get converted to a question mark (or some such thing).
There is not much that Ant can do. It cannot figure out which files are binary - a UTF-8 version of Korean will have lots of bytes with the top bit set. It is not informed about illegal character sequences by current Sun Java implementions.
One trick for filtering containing only US-ASCII is to use the ISO-8859-1 encoding. This does not seem to contain illegal character sequences, and the lower 7 bits are US-ASCII. Another trick is to change the LANG environment variable from something like "us.utf8" to "us".

http://ant.apache.org/manual/Tasks/copy.html

Symlink With Ant

2012-06-21T02:35:00.001+07:00

Description

Manages symbolic links on Unix based platforms. Can be used to make an individual link, delete a link, create multiple links from properties files, or create properties files describing links in the specified directories. Existing links are not overwritten by default.
FileSets are used to select a set of links to record, or a set of property files to create links from.

Parameters

Attribute	Description	Required
action	The type of action to perform, may be "single", "record", "recreate" or "delete".	No, defaults to single.
link	The name of the link to be created or deleted.	required for action="single" or "delete". Ignored in other actions.
resource	The resource the link should point to.	required for action="single". Ignored in other actions.
linkfilename	The name of the properties file to create in each included directory.	required for action="record". Ignored in other actions.
overwrite	Overwrite existing links or not.	No; defaults to false.
failonerror	Stop build if true, log a warning message, but do not stop the build, when the an error occurs if false.	No; defaults to true.

Parameters specified as nested elements

fileset

FileSets are used when action = "record" to select directories and linknames to be recorded. They are also used when action = "recreate" to specify both the name of the property files to be processed, and the directories in which they can be found. At least one fileset is required for each case.

Examples

Make a link named "foo" to a resource named "bar.foo" in subdir:

  <symlink link="${dir.top}/foo" resource="${dir.top}/subdir/bar.foo"/>

Record all links in subdir and it's descendants in files named "dir.links"

  <symlink action="record" linkfilename="dir.links">
     <fileset dir="${dir.top}" includes="subdir/**"/>
  </symlink>

Recreate the links recorded in the previous example:

  <symlink action="recreate">
     <fileset dir="${dir.top}" includes="subdir/**/dir.links"/>  
  </symlink>

Delete a link named "foo":

 <symlink action="delete" link="${dir.top}/foo"/>

Java 1.2 and earlier: Due to limitations on executing system level commands in Java versions earlier than 1.3 this task may have difficulty operating with a relative path in ANT_HOME. The typical symptom is an IOException where ant can't find /some/working/directory${ANT_HOME}/bin/antRun or something similar. The workaround is to change your ANT_HOME environment variable to an absolute path, which will remove the /some/working/directory portion of the above path and allow ant to find the correct commandline execution script.
LIMITATIONS: Because Java has no direct support for handling symlinks this task divines them by comparing canonical and absolute paths. On non-unix systems this may cause false positives. Furthermore, any operating system on which the command ln -s <linkname> <resourcename> is not a valid command on the command line will not be able to use action="single" or action="recreate". Action="record" and action=delete should still work. Finally, the lack of support for symlinks in Java means that all links are recorded as links to the canonical resource name. Therefore the link: link --> subdir/dir/../foo.bar will be recorded as link=subdir/foo.bar and restored as link --> subdir/foo.bar

ANT SYMLINK

2012-06-21T01:06:00.001+07:00

Ant example source code file (symlink.xml)

This example Ant source code file (symlink.xml) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Ant tags/keywords

creates, deletes, dir, error, error, file, file, link, link, os, os, should, test, this

The symlink.xml source code

<?xml version="1.0"?>

<!--

/*
 * Since the initial version of this file was deveolped on the clock on
 * an NSF grant I should say the following boilerplate:
 *
 * This material is based upon work supported by the National Science
 * Foundaton under Grant No. EIA-0196404. Any opinions, findings, and
 * conclusions or recommendations expressed in this material are those
 * of the author and do not necessarily reflect the views of the
 * National Science Foundation.
 */

-->

<project name="symlink-test" basedir="." default="all">

  <!-- 
       Since the symlink task and some of these targets rely on
       calls to exec, it may be possible for the JVM to outrun the 
       execution of the command line  system calls, so this value is
       the number of seconds we give the operating system to
       catch up before executing a task that depends on the 
       completion of previous tasks. This delay is also added to
       the end of each target so junit doesn't go testing things
       before they have finnished (hopefully). Tweak if needed.
  -->

  <property name="delay" value="3"/>
 
  <property name="tdir" value="${basedir}/test-working"/>

  <target name="setup">
      <delete dir="${tdir}"/>
      <mkdir dir="${tdir}"/>
  </target>

  <target name="all"
       depends="setup, test-single, test-delete, test-record, test-recreate, teardown"/>
 
  <!-- test for action = single -->
  <!-- 
    Creates:
         File: ${tdir}/symlink.test
         Link: ${tdir}/singletest
  -->
  <target name="test-single">
    <touch file="${tdir}/symlink.test"/>
    <symlink resource="${tdir}/symlink.test" 
             link="${tdir}/singletest" 
             failonerror="yes"/>
    <sleep seconds="${delay}"/> 
    <available file="${tdir}/symlink.test" 
               property="test.single.file.created"/>
    <available file="${tdir}/singletest" 
               property="test.single.link.created"/>
  </target>



  <!-- test for action = delete  (no calls to command line so no sleep) -->

  <!-- 
    Creates:
         (none)
    Deletes:
         Link: ${tdir}/singletest
  -->

  <target name="test-delete">
    <touch file="${tdir}/symlink.test"/>
    <symlink resource="${tdir}/symlink.test" 
             link="${tdir}/singletest" 
             failonerror="yes"/>
    <sleep seconds="${delay}"/> 

    <symlink action="delete" link="${tdir}/singletest" failonerror="yes"/>
    <symlink action="delete" link="${tdir}/symlink.test" failonerror="no"/>
    <sleep seconds="${delay}"/> 

    <available file="${tdir}/symlink.test" 
               property="test.delete.file.still.there"/>
    <available file="${tdir}/singletest" 
               property="test.delete.link.still.there"
               value="ERROR: link deletion failed"/>
    
  </target>



  <!-- test for action = record -->

  <!-- 
    Creates:
         Dir:  ${tdir}/symtest1
         Dir:  ${tdir}/symtest1/symtest2
         Dir:  ${tdir}/symtest1/symtest3
         File: ${tdir}/symtest1/file1
         File: ${tdir}/symtest1/symtest2/file2
         File: ${tdir}/symtest1/symtest3/fileA
         File: ${tdir}/symtest1/symtest3/fileB
         File: ${tdir}/symtest1/symtest3/fileC
         Link: ${tdir}/symtest1/link1==>${tdir}/symtest1/file1
         Link: ${tdir}/symtest1/link2==>${tdir}/symtest1/symtest2/file2
         Link: ${tdir}/symtest1/symtest2/link3==>
                                           ${tdir}/symtest1/symtest2/file2
         Link: ${tdir}/symtest1/dirlink==>${tdir}/symtest1/symtest3
         Link: ${tdir}/symtest1/dirlink2==>${tdir}/symtest1/symtest3
         Link: ${tdir}/symtest1/dirlink3==>${tdir}/symtest1/symtest3
         File: ${tdir}/symtest1/recorded.links
         File: ${tdir}/symtest1/symtest2/recorded.links
    Deletes:
         (none)
  -->

  <target name="test-record">

    <mkdir dir="${tdir}/symtest1"/>
    <mkdir dir="${tdir}/symtest1/symtest2"/>
    <mkdir dir="${tdir}/symtest1/symtest3"/>
    <touch file="${tdir}/symtest1/file1"/>
    <touch file="${tdir}/symtest1/symtest2/file2"/>

    <touch file="${tdir}/symtest1/symtest3/fileA"/>
    <touch file="${tdir}/symtest1/symtest3/fileB"/>
    <touch file="${tdir}/symtest1/symtest3/fileC"/>

    <symlink resource="${tdir}/symtest1/file1" 
             link="${tdir}/symtest1/link1" 
             failonerror="no" />
    <symlink resource="${tdir}/symtest1/symtest2/file2" 
             link="${tdir}/symtest1/link2" 
             failonerror="no" />
    <symlink resource="${tdir}/symtest1/symtest2/file2" 
             link="${tdir}/symtest1/symtest2/link3" 
             failonerror="no" />
    <symlink resource="${tdir}/symtest1/symtest3"
             link="${tdir}/symtest1/dirlink"
             failonerror="no" />
    <symlink resource="${tdir}/symtest1/symtest3" 
             link="${tdir}/symtest1/dirlink2"
             failonerror="no"/>
    <symlink resource="${tdir}/symtest1/symtest3" 
             link="${tdir}/symtest1/dirlink3"
             failonerror="no"/>

    <sleep seconds="${delay}"/> 

    <symlink action="record" linkfilename="recorded.links">
       <fileset dir="${tdir}/symtest1" includes="**/**"/>
    </symlink>

    <sleep seconds="${delay}"/> 

    <!-- Test to see if the directories were created -->

    <available file="${tdir}/symtest1"
               type="dir"
               property="test.record.dir1.created"/>

    <available file="${tdir}/symtest1/symtest2"
               type="dir"
               property="test.record.dir2.created"/>

    <available file="${tdir}/symtest1/symtest3"
               type="dir"
               property="test.record.dir3.created"/>

    <!-- Test to see if the Files were created -->

    <available file="${tdir}/symtest1/file1"
               property="test.record.file1.created"/>

    <available file="${tdir}/symtest1/symtest2/file2"
               property="test.record.file2.created"/>

    <available file="${tdir}/symtest1/symtest3/fileA"
               property="test.record.fileA.created"/>

    <available file="${tdir}/symtest1/symtest3/fileB"
               property="test.record.fileB.created"/>

    <available file="${tdir}/symtest1/symtest3/fileC"
               property="test.record.fileC.created"/>

    <!-- Test to see if the links were created -->

    <available file="${tdir}/symtest1/link1"
               property="test.record.link1.created"/>

    <available file="${tdir}/symtest1/link2"
               property="test.record.link2.created"/>

    <available file="${tdir}/symtest1/symtest2/link3"
               property="test.record.link3.created"/>

    <available file="${tdir}/symtest1/dirlink"
               property="test.record.dirlink.created"/>

    <!-- this is redundant for this test, but used in the recreate test -->

    <available file="${tdir}/symtest1/dirlink2" 
               property="test.record.dirlink2.created"/>

    <!-- Test to see if the linkfiles were created -->

    <available file="${tdir}/symtest1/recorded.links"
               property="test.record.dir1.recorded"/>

    <available file="${tdir}/symtest1/symtest2/recorded.links"
               property="test.record.dir2.recorded"/>

    <!-- THIS should not be set -->

    <available file="${tdir}/symtest1/symtest3/recorded.links"
               property="test.record.dir3.recorded"
               value="ERROR: symtest3/recorded.links should not exist"/>


  </target>

  <!-- test for action = recreate -->

  <!-- 
    Deletes:
         Link: ${tdir}/symtest1/link1==>${tdir}/symtest1/file1
         Link: ${tdir}/symtest1/link2==>${tdir}/symtest1/symtest2/file2
         Link: ${tdir}/symtest1/symtest2/link3==>
                                           ${tdir}/symtest1/symtest2/file2
         Link: ${tdir}/symtest1/dirlink==>${tdir}/symtest1/symtest3
         Link: ${tdir}/symtest1/dirlink3==>${tdir}/symtest1/symtest3

    Creates
         Link: ${tdir}/symtest1/dirlink3==>${tdir}/symtest1/symtest2

    Recreates:
         Link: ${tdir}/symtest1/link1==>${tdir}/symtest1/file1
         Link: ${tdir}/symtest1/link2==>${tdir}/symtest1/symtest2/file2
         Link: ${tdir}/symtest1/symtest2/link3==>
                                           ${tdir}/symtest1/symtest2/file2
         Link: ${tdir}/symtest1/dirlink==>${tdir}/symtest1/symtest3

    Should Change:
         Link: ${tdir}/symtest1/dirlink3==>${tdir}/symtest1/symtest2
               to
               ${tdir}/symtest1/dirlink3==>${tdir}/symtest1/symtest3

    Should Not Create (bug 25181):
         Link: ${tdir}/symtest1/symtest3/dirlink2==>${tdir}/symtest1/symtest3
  -->

  <target name="test-recreate" depends="test-record">

    <symlink action="delete" link="${tdir}/symtest1/link1"/>
    <symlink action="delete" link="${tdir}/symtest1/link2"/>
    <symlink action="delete" link="${tdir}/symtest1/symtest2/link3"/>
    <symlink action="delete" link="${tdir}/symtest1/dirlink"/>
    <!-- dirlink2 intentionally not deleted to test bug 25181 -->
    <symlink action="delete" link="${tdir}/symtest1/dirlink3"/>

    <sleep seconds="${delay}"/>  

    <symlink resource="${tdir}/symtest1/symtest2" 
             link="${tdir}/symtest1/dirlink3"
             failonerror="no"/>

    <sleep seconds="${delay}"/>  

    <available file="${tdir}/symtest1/link1"
               property="test.recreate.link1.not.removed"
               value="ERROR: rm -f symtest1/link1 failed"/>

    <available file="${tdir}/symtest1/link2"
               property="test.recreate.link2.not.removed"
               value="ERROR: rm -f symtest1/link2 failed"/>

    <available file="${tdir}/symtest1/symtest2/link3"
               property="test.recreate.link3.not.removed"
               value="ERROR: rm -f symtest1/symtest2/link3 failed"/>

     <available file="${tdir}/symtest1/zdirlink"
               property="test.recreate.zdirlink.not.removed"
               value="ERROR: rm -f symtest1/zdirlink failed"/>

    <sleep seconds="${delay}"/>  

    <symlink action="recreate">
      <fileset dir="${tdir}/symtest1" includes="**/recorded.links"/>
    </symlink>

    <sleep seconds="${delay}"/>  

    <available file="${tdir}/symtest1/link1"
               property="test.recreate.link1.recreated"/>

    <available file="${tdir}/symtest1/link2"
               property="test.recreate.link2.recreated"/>

    <available file="${tdir}/symtest1/symtest2/link3"
               property="test.recreate.link3.recreated"/>

    <available file="${tdir}/symtest1/dirlink"
               property="test.recreate.dirlink.recreated"/>

    <!-- this should not get set -->
    <available file="${tdir}/symtest1/symtest3/symtest3" 
               property="test.recreate.dirlink2.recreated.twice"
               value="ERROR: dirlink2 was created a second time (bug 25181)"/>

    <touch file="${tdir}/symtest1/dirlink3/WhereAmI"/>

    <sleep seconds="${delay}"/>  

    <available file="${tdir}/symtest1/symtest3/WhereAmI" 
               property="test.recreate.dirlink3.was.altered"/>
  </target>


<!-- CALL THIS to clean things up afterwards -->

  <target name="teardown">
    <delete dir="${tdir}"/>
  </target>

</project>

Other Ant examples (source code examples)

Eclipse Ant Builder

2012-06-21T00:55:00.001+07:00

Tutorial: Hello World with Apache Ant

This document provides a step by step tutorial for starting java programming with Apache Ant. It does not contain deeper knowledge about Java or Ant. This tutorial has the goal to let you see, how to do the easiest steps in Ant.

Content

Preparing the project

We want to separate the source from the generated files, so our java source files will be in src folder. All generated files should be under build, and there splitted into several subdirectories for the individual steps: classes for our compiled files and jar for our own JAR-file.
We have to create only the src directory. (Because I am working on Windows, here is the win-syntax - translate to your shell):

md src

The following simple Java class just prints a fixed message out to STDOUT, so just write this code into src\oata\HelloWorld.java.

package oata;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Now just try to compile and run that:

md build\classes
javac -sourcepath src -d build\classes src\oata\HelloWorld.java
java -cp build\classes oata.HelloWorld

which will result in

Hello World

Creating a jar-file is not very difficult. But creating a startable jar-file needs more steps: create a manifest-file containing the start class, creating the target directory and archiving the files.

echo Main-Class: oata.HelloWorld>myManifest
md build\jar
jar cfm build\jar\HelloWorld.jar myManifest -C build\classes .
java -jar build\jar\HelloWorld.jar

Note: Do not have blanks around the >-sign in the echo Main-Class instruction because it would falsify it!

Four steps to a running application

After finishing the java-only step we have to think about our build process. We have to compile our code, otherwise we couldn't start the program. Oh - "start" - yes, we could provide a target for that. We should package our application. Now it's only one class - but if you want to provide a download, no one would download several hundreds files ... (think about a complex Swing GUI - so let us create a jar file. A startable jar file would be nice ... And it's a good practise to have a "clean" target, which deletes all the generated stuff. Many failures could be solved just by a "clean build".
By default Ant uses build.xml as the name for a buildfile, so our .\build.xml would be:

<project>

    <target name="clean">
        <delete dir="build"/>
    </target>

    <target name="compile">
        <mkdir dir="build/classes"/>
        <javac srcdir="src" destdir="build/classes"/>
    </target>

    <target name="jar">
        <mkdir dir="build/jar"/>
        <jar destfile="build/jar/HelloWorld.jar" basedir="build/classes">
            <manifest>
                <attribute name="Main-Class" value="oata.HelloWorld"/>
            </manifest>
        </jar>
    </target>

    <target name="run">
        <java jar="build/jar/HelloWorld.jar" fork="true"/>
    </target>

</project>

Now you can compile, package and run the application via

ant compile
ant jar
ant run

Or shorter with

ant compile jar run

While having a look at the buildfile, we will see some similar steps between Ant and the java-only commands:

java-only

Ant

md build\classes
javac
    -sourcepath src
    -d build\classes
    src\oata\HelloWorld.java
echo Main-Class: oata.HelloWorld>mf
md build\jar
jar cfm
    build\jar\HelloWorld.jar
    mf
    -C build\classes
    .



java -jar build\jar\HelloWorld.jar

<mkdir dir="build/classes"/>
<javac
    srcdir="src"
    destdir="build/classes"/>
<!-- automatically detected -->
<!-- obsolete; done via manifest tag -->
<mkdir dir="build/jar"/>
<jar
    destfile="build/jar/HelloWorld.jar"

    basedir="build/classes">
    <manifest>
        <attribute name="Main-Class" value="oata.HelloWorld"/>
    </manifest>
</jar>
<java jar="build/jar/HelloWorld.jar" fork="true"/>

Enhance the build file

Now we have a working buildfile we could do some enhancements: many time you are referencing the same directories, main-class and jar-name are hard coded, and while invocation you have to remember the right order of build steps.
The first and second point would be addressed with properties, the third with a special property - an attribute of the <project>-tag and the fourth problem can be solved using dependencies.

<project name="HelloWorld" basedir="." default="main">

    <property name="src.dir"     value="src"/>

    <property name="build.dir"   value="build"/>
    <property name="classes.dir" value="${build.dir}/classes"/>
    <property name="jar.dir"     value="${build.dir}/jar"/>

    <property name="main-class"  value="oata.HelloWorld"/>



    <target name="clean">
        <delete dir="${build.dir}"/>
    </target>

    <target name="compile">
        <mkdir dir="${classes.dir}"/>
        <javac srcdir="${src.dir}" destdir="${classes.dir}"/>
    </target>

    <target name="jar" depends="compile">
        <mkdir dir="${jar.dir}"/>
        <jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
            <manifest>
                <attribute name="Main-Class" value="${main-class}"/>
            </manifest>
        </jar>
    </target>

    <target name="run" depends="jar">
        <java jar="${jar.dir}/${ant.project.name}.jar" fork="true"/>
    </target>

    <target name="clean-build" depends="clean,jar"/>

    <target name="main" depends="clean,run"/>

</project>

Now it's easier, just do a ant and you will get

Buildfile: build.xml

clean:

compile:
    [mkdir] Created dir: C:\...\build\classes
    [javac] Compiling 1 source file to C:\...\build\classes

jar:
    [mkdir] Created dir: C:\...\build\jar
      [jar] Building jar: C:\...\build\jar\HelloWorld.jar

run:
     [java] Hello World

main:

BUILD SUCCESSFUL

Using external libraries

Somehow told us not to use syso-statements. For log-Statements we should use a Logging-API - customizable on a high degree (including switching off during usual life (= not development) execution). We use Log4J for that, because

it is not part of the JDK (1.4+) and we want to show how to use external libs
it can run under JDK 1.2 (as Ant)
it's highly configurable
it's from Apache ;-)

We store our external libraries in a new directory lib. Log4J can be downloaded [1] from Logging's Homepage. Create the lib directory and extract the log4j-1.2.9.jar into that lib-directory. After that we have to modify our java source to use that library and our buildfile so that this library could be accessed during compilation and run.
Working with Log4J is documented inside its manual. Here we use the MyApp-example from the Short Manual [2]. First we have to modify the java source to use the logging framework:

package oata;

import org.apache.log4j.Logger;
import org.apache.log4j.BasicConfigurator;

public class HelloWorld {
    static Logger logger = Logger.getLogger(HelloWorld.class);

    public static void main(String[] args) {
        BasicConfigurator.configure();
        logger.info("Hello World");          // the old SysO-statement
    }
}

Most of the modifications are "framework overhead" which has to be done once. The blue line is our "old System-out" statement.
Don't try to run ant - you will only get lot of compiler errors. Log4J is not inside the classpath so we have to do a little work here. But do not change the CLASSPATH environment variable! This is only for this project and maybe you would break other environments (this is one of the most famous mistakes when working with Ant). We introduce Log4J (or to be more precise: all libraries (jar-files) which are somewhere under .\lib) into our buildfile:

<project name="HelloWorld" basedir="." default="main">
    ...
    <property name="lib.dir"     value="lib"/>

    <path id="classpath">
        <fileset dir="${lib.dir}" includes="**/*.jar"/>
    </path>

    ...

    <target name="compile">
        <mkdir dir="${classes.dir}"/>
        <javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="classpath"/>
    </target>

    <target name="run" depends="jar">
        <java fork="true" classname="${main-class}">
            <classpath>
                <path refid="classpath"/>
                <path location="${jar.dir}/${ant.project.name}.jar"/>
            </classpath>
        </java>
    </target>

    ...

</project>

In this example we start our application not via its Main-Class manifest-attribute, because we could not provide a jarname and a classpath. So add our class in the red line to the already defined path and start as usual. Running ant would give (after the usual compile stuff):

[java] 0 [main] INFO oata.HelloWorld  - Hello World

What's that?

[java] Ant task running at the moment
0 sorry don't know - some Log4J stuff
[main] the running thread from our application
INFO log level of that statement
oata.HelloWorld source of that statement
- separator
Hello World the message

For another layout ... have a look inside Log4J's documentation about using other PatternLayout's.

Configuration files

Why we have used Log4J? "It's highly configurable"? No - all is hard coded! But that is not the debt of Log4J - it's ours. We had coded BasicConfigurator.configure(); which implies a simple, but hard coded configuration. More confortable would be using a property file. In the java source delete the BasicConfiguration-line from the main() method (and the related import-statement). Log4J will search then for a configuration as described in it's manual. Then create a new file src/log4j.properties. That's the default name for Log4J's configuration and using that name would make life easier - not only the framework knows what is inside, you too!

log4j.rootLogger=DEBUG, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%m%n

This configuration creates an output channel ("Appender") to console named as stdout which prints the message (%m) followed by a line feed (%n) - same as the earlier System.out.println() :-) Oooh kay - but we haven't finished yet. We should deliver the configuration file, too. So we change the buildfile:

    ...
    <target name="compile">
        <mkdir dir="${classes.dir}"/>
        <javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="classpath"/>
        <copy todir="${classes.dir}">
            <fileset dir="${src.dir}" excludes="**/*.java"/>
        </copy>
    </target>
    ...

This copies all resources (as long as they haven't the suffix ".java") to the build directory, so we could start the application from that directory and these files will included into the jar.

Testing the class

In this step we will introduce the usage of the JUnit [3] testframework in combination with Ant. Because Ant has a built-in JUnit 3.8.2 you could start directly using it. Write a test class in src\HelloWorldTest.java:

public class HelloWorldTest extends junit.framework.TestCase {

    public void testNothing() {
    }
    
    public void testWillAlwaysFail() {
        fail("An error message");
    }
    
}

Because we dont have real business logic to test, this test class is very small: just show how to start. For further information see the JUnit documentation [3] and the manual of junit task. Now we add a junit instruction to our buildfile:

    ...

    <path id="application" location="${jar.dir}/${ant.project.name}.jar"/>

    <target name="run" depends="jar">
        <java fork="true" classname="${main-class}">
            <classpath>
                <path refid="classpath"/>
                <path refid="application"/>
            </classpath>
        </java>
    </target>
    
    <target name="junit" depends="jar">
        <junit printsummary="yes">
            <classpath>
                <path refid="classpath"/>
                <path refid="application"/>
            </classpath>
            
            <batchtest fork="yes">
                <fileset dir="${src.dir}" includes="*Test.java"/>
            </batchtest>
        </junit>
    </target>

    ...

We reuse the path to our own jar file as defined in run-target by giving it an ID and making it globally available. The printsummary=yes lets us see more detailed information than just a "FAILED" or "PASSED" message. How much tests failed? Some errors? Printsummary lets us know. The classpath is set up to find our classes. To run tests the batchtest here is used, so you could easily add more test classes in the future just by naming them *Test.java. This is a common naming scheme.
After a ant junit you'll get:

...
junit:
    [junit] Running HelloWorldTest
    [junit] Tests run: 2, Failures: 1, Errors: 0, Time elapsed: 0,01 sec
    [junit] Test HelloWorldTest FAILED

BUILD SUCCESSFUL
...

We can also produce a report. Something that you (and other) could read after closing the shell .... There are two steps: 1. let <junit> log the information and 2. convert these to something readable (browsable).

    ...
    <property name="report.dir"  value="${build.dir}/junitreport"/>
    ...
    <target name="junit" depends="jar">
        <mkdir dir="${report.dir}"/>
        <junit printsummary="yes">
            <classpath>
                <path refid="classpath"/>
                <path refid="application"/>
            </classpath>
            
            <formatter type="xml"/>
            
            <batchtest fork="yes" todir="${report.dir}">
                <fileset dir="${src.dir}" includes="*Test.java"/>
            </batchtest>
        </junit>
    </target>
    
    <target name="junitreport">
        <junitreport todir="${report.dir}">
            <fileset dir="${report.dir}" includes="TEST-*.xml"/>
            <report todir="${report.dir}"/>
        </junitreport>
    </target>

Because we would produce a lot of files and these files would be written to the current directory by default, we define a report directory, create it before running the junit and redirect the logging to it. The log format is XML so junitreport could parse it. In a second target junitreport should create a browsable HTML-report for all generated xml-log files in the report directory. Now you can open the ${report.dir}\index.html and see the result (looks something like JavaDoc).
Personally I use two different targets for junit and junitreport. Generating the HTML report needs some time and you dont need the HTML report just for testing, e.g. if you are fixing an error or a integration server is doing a job.

Resources

    [1] http://www.apache.org/dist/logging/log4j/1.2.13/logging-log4j-1.2.13.zip
    [2] http://logging.apache.org/log4j/docs/manual.html
    [3] http://www.junit.org/index.htm

Java SQL Connect

2012-06-11T18:15:00.001+07:00

Are you asking ‘Could I connect Java application/applet to database like MySQL?’ and the answer is definitely Yes.

You can use JDBC (Java Database Connectivity) to connect your Java application/applet with database. So Let’s start.

First, Create new Project named anything you want, for example Javasql by click File->New Project.

newProject

then you’ll be on this frame

javaapps

then click next, then give Project Name and set Project Localtion

nameProject

then finish.

Second, you must have JDBC MySQL Driver before you can start to connect your Java program to database. But since we use Netbeans , this has been done. Just simply add the library to your project library. Right click in Library on the Project you use.

Then choose MySQL JDBC Driver

Then Click Add Libary.

So now we can connect to MySQL database. Here is the example how you can connect to MySQL.

Here, we use interface Connection.

package javasql;
import com.mysql.jdbc.Driver;
import java.sql.*;
/**
 *
 * @author Ferdiansyah Dolot
 */
public class Connect {
    public Connect() throws SQLException{
        makeConnection();
    } 

    private Connection koneksi;  

     public  Connection makeConnection() throws SQLException {
        if (koneksi == null) {
             new Driver();
            // buat koneksi
             koneksi = DriverManager.getConnection(
                       "jdbc:mysql://localhost/databasename",
                       "username",
                       "password");
         }
         return koneksi;
     }  

     public static void main(String args[]) {
         try {
             Connect c = new Connect();
             System.out.println("Connection established");
         }
         catch (SQLException e) {
             e.printStackTrace();
             System.err.println("Connection Failure");
         }  

    }
}

In example above we create connection to MySQL from creating object of Driver and get connection from DriverManager (get Connection will return Connection Object type), with parameter the url, username, and password. The url above means the database is located in localhost and the name is databasename.You can also add port for MySQL so the url looks : “jdbc:mysql://localhost:3306/databasename”. (See port 3306).
So now we can make a connection to MySQL database. Now, how can we do SQL statement like update, delete, insert, etc?

We will discuss this in Java MySQL JDBC Tutorial using NetBeans (Part 2).

http://ferdidolot.wordpress.com/2009/06/14/java-mysql-jdbc-tutorial-using-netbeans-part-1/

SAMSUNG MOBILE FMWARE

2012-06-08T17:28:00.002+07:00

http://www.sammobile.com/firmware/?page=3&t=1&o=1&m=GT-S5830&r=2#regiona

UNROOT GALAXY ACE

2012-06-08T17:25:00.003+07:00

http://handzmentallist.blogspot.com/2012/04/cara-unroot-samsung-galaxy-ace.html

ROM GALAXY ACE 2.3.4

2012-06-08T15:32:00.002+07:00

GALAXY ACE 2.3.4
http://www.proghita.com/root-sederhana-gingerbread-2-3-4-galaxy-ace-ala-proghita/

PARTISI SDCARD For Android
http://note.izor.web.id/2011/05/cara-membagi-partisi-sd-card-pada.html

PHP Regular Expression

2012-06-04T11:24:00.001+07:00

Regular Expression atau Regex, merupakan sebuah teknik atau cara untuk mencari persamaan - presamaan atau mencari string yang di cocokan dengan string tertentu,dalam php yang paling banyak digunakan adalah PCRE atau (Perl Compatible Regular Expressions), penggunaan dari regex sebebenarnya cukup luas, secara umum digunkan untuk mencari string (kata, huruf, simbol) dalam kumpulan-kumpulan string, misalnya ada sebuah string "saya pergi sekolah", dalam string tersebut terdapat beberapa kata, dan kita ingin mencari beberapa kata dengan kondisi tertentu, misalnya mencari kata dengan awalan p, atau mencari kata dengan akhiran a atau mencari kata di antara kata saya dan kata sekolah, di sinilah regex berperan, untuk mencari string dalam string dengan patern (kondisi) tertentu.
Untuk lebih memahami mari kita mencoba implementasi regex, dengan membuats sebuah program sederahan

<?php

// buat  string

$string = 'abcdefghijklmnopqrstuvwxyz0123456789';

// tulisakan hasil string

echo $string;

?>

Jika Program tersebut di jalankan tentu saja string yang tampil adalah string secara keseluruhan, karena kita tidak menerapkan fungsi regex di dalamnya, sekarang kita akan mencoba mencari string "abc" dalam string yang ada, secara simple nya kita akan mencoba mencari apakah string "abc" ada dalam kumpulan string dengan variabel $string

<?php

$string = 'abcdefghijklmnopqrstuvwxyz0123456789';

echo preg_match("/abc/", $string);

?>

Program di atas akan menghasilkan 1 (true), itu karena patern string yang kita gunakan (abc) ada dalam string sebelemunya, dengan menggunakan preg_match() hasil yang di dapatkan akan berupa 1 jika patern ditemukan atau sebaliknya akan manampilkan 0 jika patern tidak ditemukan, tetapi yang perlu di ingat adalah penggunaan preg_match() dalam sekala yang lebih besar tidaklah terlalu baik, penggunaan strpos() atau strstr() akan jauh lebih baik dibandingkan dengan preg_match(), tetapi disini kita akan menggunakan preg_match(), karena ini juga contoh yang sederhana :)

Mecocokan Awalan dari String

Disini kita akan mencoba mencari string yang awalan dari string tersebut kita tentukan dalam patern kita, misalnya mencari string yang berawalan P, atau mencari string yang berawalan m dan lainya, dalam regex kita akan menggunkan simbol ^ sebagai penanda bahwa kita mencari kecocokan awalan dari string yang kita berikan,

<?php

// string

$string = 'abcdefghijklmnopqrstuvwxyz0123456789';

// mencoba mencocokan awalan dari string

if(preg_match("/^abc/", $string))

{

    //jika awalan ditemukan

    echo 'String dimulai dengan abc';

    }

    else

    {

    //jika awalan tidak ditemukan

    echo 'string tidak di awali dengan abc';

}

?>

Jika kita menjalankan program di atas, kita akan mendapatkan pesan String dimulai dengan abc, tanda / dan \ merupakan delimeter (cakupan) dari regex yang kita berikan, sedangkan simbol ^ mencocokan awalan dari string tanpa memperdulikan string setelahnya

case insensitive

Jika kita menggunakan code di atas untuk mencari string dengan awaln ABC dengan patern seperti if (preg_match("/^ABC/", $string)) hasinya string tidak di awali dengan abc, karena memang tidak ada string yang di awali dengan ABC, walapun pada hakikatnya abc = ABC, tetapi dalam programming kadang itu bisa menjadi sesuatu yang berbeda, untuk itu kita harus memberi tau kan kepada regex kita bahwa hal itu tidaklah berbeda, dengan cara menambahkan huruf i di akhir delimeter patern yang kita berikan, dengan begitu regex tidak akan memperdulikan huruf kecil dan huruf besar, atau kita akan mencari awalan string tanpa memperdulikan huruf besar atau tidak, seperti ABC, AbC, abc, ABc dll

<?php

// string

$string = 'abcdefghijklmnopqrstuvwxyz0123456789';

// mencoba mencocokan awalan dari string

if(preg_match("/^ABC/i", $string))

{

    //jika awalan ditemukan

    echo 'String dimulai dengan abc';

    }

    else

    {

    //jika awalan tidak ditemukan

    echo 'string tidak di awali dengan abc';

}

?>

Mecocokan Akhiran dari String

Jika tadi kita sudah membahas cara sederhana untuk mencari kecocokan string di awalan string, sekarang kita akan mencoba mencari kecocokan di akhiran string, caranya tidak jauh berbeda dengan cara sebelumunya, kita tetap meggunakan simbol ^ sebagai patern regex, hanya bedanya simbol ^ kita berikan di awal patern regex dan menambahkan patern \z di akhir, misalnya kita mencari string yang berakhiran 89 maka patern yang kita berikan adalah preg_match("/89\z/i", $string), tetapi dalam implentasinya banyak yang melakukan kesalahan dalam menerapakan regex yang mencari kecocokan di akhiran string dengan menggunkan simbol $, sebenarnya itu salah, seharusnya kita menggunkan patern \z untuk mencari kecocokan di akhiran string, karena jika menggunakan simbol $ saja hasilnya akan selalu true (1) jika memang patern ditemukan, tetapi masalahnya bagaimana jika masih ada baris selanjutnya ? , tentu saja hasilnya tidak akan sesuai dengan harapn kita, untuk itulah simbol patern $ tidak diperlukan.kecuali jika memang kita mencari akhiran dalam string mempunyai banyak baris., seperti contoh berikut

<?php

//string

$string = 'abcdefghijklmnopqrstuvwxyz0123456789';

if(preg_match("/89\z/i", $string))

{

    echo 'String dikahiri dengan 89';

    }

    else

    {

    echo 'String tidak diakhiri dengan 89';

}

?>

Dan jika string yang kita gunakan mempunyai baris-baris lainya kitaa seharunya menggunakan regex seperti berikut

<?php

//string

$string = 'abcdefghijklmnopqrstuv

wxyz0123456789';

if(preg_match("/^89$/i", $string))

{

    echo 'String dikahiri dengan 89';

    }

    else

    {

    echo 'String tidak diakhiri dengan 89';

}

?>

Perbedaanya cukup jelas kan, penggunaan patern preg_match("/89\z/i", $string) dengan patern preg_match("/^89$/",$string), patern - patern tersebut menunjukan perbedaan string yang mempunyai baris dengan string yang tidak mempunyai baris, penggunaan seperti inilah yang perlu di perhatikan, jika tidak kita pasti beranggapan bahwa patern kita salah atau sebaliknya :)

Meta characters

Di awal kita sudah mengenal beberapa simbol yang kita gunakan dalam regex, seperti simbol ^ yang menunjukan awal dari string, dam simbol $ dan \z yang menunjukan akhir dari string, masing-masing dari simbol tersebut mempunyai fungsi dan arti tersendiri dalam regex,tetapi dalam regex masih banyak simbol - simbol lainya yang juga memiliki arti dan fungsi tersendiri, seperti berikut

. (full stop)
^ (Caret)
* (Asterix)
+ (Plus)
? (Question Mark)
{ (Opening Curly brace)
} (Closing Curly brace)
[ (Opening Brace)
] (Closing Brace)
\ (Back Slah)
| (Pipe)
( (Opening Parens)
( (Closing Parens)

Kita akan mencoba membahas satu persatu dalam tutorial ini, yang paling adalah kita mengerti apa mereka (simbol tersebut), misalnya penggunaan \ (Black slah) digunakan ketika kita akan meng-escape karakter terntentu seperti < atau > atau + atau karakter yang termasuk dalam meta characters di atas, misalnya kita akan mengescape karakter dalam string 1+1, kita akan mencari karakter dengan awalan 1+1 dalam string tertentu

<?php

//string

$string = '1+1=2';

if(preg_match("/^1\+1/i", $string))

{

    echo 'String diawali dengan 1+1';

    }

    else

    {

    echo 'String tidak diawali dengan 1+1';

}

?>

Jika program tersebut di jalankan, kita akan mendapatkan hasil String diawali dengan 1+1, karena patern 1+1 ditemukan dalam string fungsi \ (back slah) diatas akan membiarkan tanda + sebagai tanda +, bukan sebagai meta characters,dan jika kita tidak memberikan simbol \ maka hasilnya akan String tidak diawali dengan 1+1, akrena patern tidak cocok, regex meng-anggap bahwa tanda + merupakan meta characters, jika dalam percobaan teman-teman menemukan string yang menggunakan \ maka simbol \ harus di escape terlebih dahulu dengan memberikan simbol \ double (\\) sehingga simbol \ dalam string akan di anggap sebagai patern bukan sebagai meta characters.

Meta characters in Actions

Saya harap sampai disini teman-teman masih belum bosan :D, jika di awal kita telah membahas simbol ^, $ dan \ maka sekarang kita mencoba membahas sedikit tentang meta characters yang lainnya, seperti misalnya penggunaan simbol [ dan ], beberapa waktu lalu sempat seorang teman bertanya kepada saya masalah perbedaan tanda tersebut dengan simbol (), mudah-mudahan tutorial ini bisa menjawabnya
simbol [ dan ] digunakan untuk memberitahukan kepada regex bahwa kita menggunakan patern yang lebih spesipik, misalnya hanya [aiueo] saja, atau [a-z] saja, atau [0-9] saja dan aptern yang lainya, tanda - menunjukan range (sampai) dalam kondisi tertentu seperti a sampai z atau 0 sampai 9, seperti contoh berikut

<?php

// string

$string = 'big';

echo preg_match("/b[aiueo]g/", $string, $matches);

?>

Jika kita jalankan program di atas akan menghasilkan true(1), karena preg_match() menemukan patern yang kita berikan (cocok), kenapa ? karena pada regex diatas kita memberikan patern preg_match("/b[aiueo]g/",$string) yang artinya kita mencari kata "b?g" dan huruf di antara b dan g bisa berbentuk "aiueo"m jadi misalnya dalam string terdapat kata big maka hasilnya akan true karena i terdapat dalam patern kita, dan jika seandainya dalam string terdapat kata bug, maka nulinya akan tetap true(1), karena u ada dalam patern yang kita berikan, simple bukan ? yang perlu di ingat adalah meta characters tidak akan bekerja jika kita masukan dapal regex [ dan ], misalnya preg_match("/b[^1\+1]g/", $string),jadi penggunaan simbol [ dan ] hanya untuk mencari kecocokan dalam ruang lingkup tertentu saja
Dan bagaiaman jika kita ingin mencari string yang cocok tetapi didalamnya terdapat salah satu meta characters di atas ? atau mencari string yang cocok dalam range tertentu, memang benar, penggunaan meta characters dalam simbol [ dan ] tidak diperbolehkan, tetapi kadang - kadang boleh :D, tetapi dengan kondisi tertentu, misalnya kita ingin mencari string yang tidak di awali dengan string b dalam string, ingat TIDAK di awali, bukan di AWALI, berikut contohnya

<?php

$string = 'abcefghijklmnopqrstuvwxyz0123456789';

preg_match("/[^b]/", $string, $matches);

foreach($matches as $key=>$value)

    {

    echo $key.' -> '.$value;

    }

?>

Jika program di atas di jalankan kan, kita akan mendapatkan hasil 0->a, karena hanya dua string tersebut yang tidak di awali dengan string b, masih bingung ya ?, jika kita kembali ke awal, penggunaan simbol [ dan ] menunjukan penggunaan yang lebih spesipik, string [a-z] dan [0-9], dalam string yang kita berikan terdapat dua cakupan, maka regex meng-anggap bahwa itu dua range yang berbeda, itulah penyebabnya kenapa kita mendapatkan hasil 0->a, sekarang sudah mengertikan ?
Sekarang mari kita merubah sedikit program kita, jika pada awalnya kita menggunakan fungsi preg_match(), sekarang kita akan mencoba menggunakan fungsi preg_match_all() dalam mencari string yang TIDAK DIAWALI dengan string b dengan patern preg_match_all("/[^b]/",$string,$matches)

<?php

$string = 'abcefghijklmnopqrstuvwxyz0123456789';

preg_match_all("/[^b]/", $string, $matches);

foreach($matches as $key=>$value)

    {

    echo $value;

    }

?>

Jika program tersebut kita jalankan hasilnya adalah acefghijklmnopqrstuvwxyz0123456789, coba perhatikan hasilnya, tidak ada string b kan ? , ini karena kita mencari semua karakter yang tidak sama dengan string b /[^b]/, berbeda dengan penggunaan preg_match(), preg_match_all() lebih kepada hasil yang menunjukan kecocokan pada string, nah dengan demikian kita bisa menarik keluar string terntentu dari string tersebut, misalnya kita ingin mencari string yang tidak sama dengan huruf dari 0 -9 dari string tersebut, dengan menggunakan preg_match_all() kita bisa melakukannya, seperti contoh

<?php

$string = 'abcefghijklmnopqrstuvwxyz0123456789';

preg_match_all("/[^0-9]/", $string, $matches);

foreach($matches as $key=>$value)

    {

    echo $value;

    }

?>

hasil dari program tersebut adalah abcefghijklmnopqrstuvwxyz, sekarang sudah mengerti kan penggunaan preg_match() dan preg_match_all() ? dan kita bisa melihat tanda ^ dalam simbol [ dan ], di sini kita bisa menyimpulkan bahwa simbol ^ jika berada dalam simbol [ dan ] bukan berarti awalan atau akhiran, tetapi menunjukan kondisi NOT atau TIDAK.

Lebih jauh tentang Escaping Character

Disini kita akan lebih kapada bagaimana memanfaatkan simbol \ dalam meng-escape karakter terentu, meng-sacape bisa di artikan sabagai membaypass, atau melewati sehingga karekter teresbut bisa di proses.misalnya kita akan mencari string yang berada dalam simbol [ dan ], contohnya seperti berikut

<?php

$string = 'ini adalah [stringsaya]';

preg_match_all("/[\[\]]/", $string, $matches);

foreach($matches[0] as $value)

{

    echo $value;

}

?>

Jika kita menjalankan program di atas maka hasilnya akan kosong atau hanya [], karena kita hanya memberikan patern untuk string yang cocok dengan simbol [ dan ], jika kita perhatikan patern tersebut tanpa menggunakan simbol black slah \ maka bentuknya akan seperti /[[]]/, dan jika kita hanya mencari dan megambil string yang berada di antara apitan simbol [ dan ] kita harus memberikan meta characters yang berbeda, yang menunjukan string apapun yang berada di antara simbol [ dan ], dengan catatan kita tidak menggunakan simbol [ dan ] sebagai regex, seperti contoh

<?php

$string = 'ini adalah [stringsaya]';

preg_match_all("/\[.*\]/", $string, $matches);

print_r($matches);

?>

Jika Program tersebut di jalankan akan menampilkan [stringsaya] dalam susun array, dan bandingkan regex yang ada dengan regex sebelumnya, pasti teman-teman bisa memahami maksudnya
sekarang kita mencoba meta characters . (full stop), simbol ini akan mencocokan semua string kecuali di pisahkan oleh bari baru seperti \n atau \r, dan jika kita ingin mencari semua string yang tidak memperdulikan baris baru seperti pemisahan \r dan \n kita cukup menambahkan flag \s di akhir delimeter regex yang kita berikan, seperti contoh

<?php

$string = 'sex at noon taxes';

echo preg_match("/s.x/", $string, $matches);

?>

Jika program di jalankan, hasilnya akan true (1), karena preg_match() menemukan 1 patern yang cocok, arti regex tersebut dapat di artikan seperti halnya kita menccari string di antara string s dan x tetapi hanya satu karakter saja, tidak perduli karakter itu berbentuk apa, misalnya sex, six, sox, s0x,s3x, daln lainya, jika karakternya berbentuk seix atau seex maka hasilnya akan 0 atau preg_match() tidak menemukan 1 patern yang cocok
Sekarang mari kita coba untuk string yang memiiki baris yang dipisahkan oleh \r atau \n, seperti contoh

<?php

$string = 'sex'."\n".'at'."\n".'noon'."\n".'taxes'."\n";

echo nl2br($string);

echo preg_match_all("/\s/", $string, $matches);

?>

jika program di jalankan hasilnya akan menunjukan string yang cocok dengan patern dan di pisahkan oleh pindah baris seperti \r dan \n, dan pada akhir akan tampil angka 4 yang menunjukan jumlah dari pindah baris yang ada karena kita menggunakan preg_match_all().
meta characters selajutnya adalah simbol *, simbol * digunakan untuk mencocokan string apa saja seperti penggunaan .*, simbol * akan meng-anggap cocok setiap string yang ada sebelum mapun sesudah dari patern yang kita berikan, bingung ya, let take it in action

<?php

$string = 'php';

echo preg_match("/ph*p/", $string, $matches);

?>

Hasil dari script di atas akan menghasilkan nilai 1, karena kita mencari kecocokan ada tidaknya string sesudah string h dari patern yang kita berikan, ada dan tidaknya string setelah string h tidak menjadi masalah, karena simbol * akan menghasilkan nilai satu, jika string berbentuk pp atau phhhhp maka hasilnya akan tetap 1, intinya kita mencari string yang cocok dengan p????p ? merupakan pengganti dari simbol *, jadi ada tidaknya string sesudah maupun sebelum string h akan di anggap ada karena kita menggunakan meta characters *
berbeda dengan simbol +, jika simbol * mencocokan semaunya, simbol + merupakan kebalikanya, jika menggunakan simbol * string pp dinaggap memiliki kecocokan maka jika kita menggunakan simbol + maka string pp tidak memiliki kecocokan dengan patern yang kita berikan, lihat contoh

<?php

$string = 'pp';

echo preg_match("/ph+p/", $string, $matches);

?>

Hasilnya akan 0, karena simbol + tidak meng-anggap ada patern yang cocok, Berbeda juga dengan simbol ?, penggunaan simbol ? hampir sama dengan simbol + dan *, hanya saja simbol ? digunakan untuk optional regex, seperti .*? yang mengartikan semuanya,
Yang paling sering digunakan dalam regex sebenarnya adalah simbol { dan }, karena dengan menggunakan simbol ini regex menjadi lebih ampuh dalam mencocokan patern dengan string, misalnya kita ingin mencari string numeric dalam sebuah string yang jumlahnya sebanyak 3 digit saja, seperti contoh

<?php

$string = 'PHP123';

echo preg_match("/PHP[0-9]{3}/", $string, $matches);

?>

Dalam regex tersebut kita memberikan patern untuk mencari dan mencocokan string dengan patern yang ita berikan, singkatnya kita mencari angka dalam string yang jumlah digitnya 3 (tiga), patern [0-9] menunjukan kalo kita mencari jenis numeric sedangkan {3} menujukan kalo kita mencari yang jumlah digitnya sebanyak 3 digit

Special Sequences

Sequences merupakan pradefined dalam class yang kita gunakan, digunakan untuk menggantikan beberapa regex yang panjang sehingga menjadi lebih singkat, Sequences di lambangkan dengan huruf dan di letakan di belakang delimeter regex, berikut beberapa jenis dan fungsinya

\d digunakan untuk mencocokan semua jenis angka, sama dengan [0-9]
\D digunakan untuk mencocokan semua jenis yang bukan angka sama dengan [^0-9]
\s digunakan untuk mencocokan semua whitespaces, sama dengan [\t\n\r\f\v]
\S digunakan untuk mencocokan semua non whitespaces, sama dengan [^\t\n\r\f\v]
\w digunakan untuk Alphanumeric sama dengan [a-zA-Z0-9]
\W digunakan untuk non-Alphanumeric, sama dengan [^a-zA-Z0-9]

Jika kita implementasikan kedalam program, misalnya untuk mencari semua string yang hanya berupa alpha numeric, kita dapat menggunakan preg_match_all() dan Sequences \w, seperti contoh

<?php

$string = 'ab-ce*fg@ hi & jkl(mnopqr)stu+vw?x yz0>1234<567890';

preg_match_all("/[\w]/", $string, $matches);

foreach($matches[0] as $value)

{

    echo $value;

}

?>

Jika kita jalankan, maka semua karakter yang termasuk dalam Alphanumeric akan tampil, karena kita memberikan Sequences \w dalam regex, berbeda jika kita memberikan Sequences \W maka yang tampil adalah semua karakter yang bukan Alphanumeric, untuk penggunaan Sequences yang lain juga sama, tergntung fungsinya saja

Capturing Text Inside HTML Tags

skerang kita akan mencoba menggunakan regex dalam html, kita akan mencoba mengambil beberapa string berdasarkan tag html, untuk penjelsan dari masing-masing regex saya rasa sudah cukup jelas dari awal sampai akhir, di bagian ini kita akan mencoba menggabungkannya menjadi satu

<?php

$html = file_get_contents('http://www.contoh.org/example.html');

preg_match_all('@<h([1-6])>(.+?)</h\1>@is', $html, $matches);

foreach ($matches[2] as $text) {

    print "Heading: $text \n";

}

?>

Program di atas jika di jalankan akang menampilkan semua string yang berada dalam tag h1 sampai h6, untuk hasilnya teman-teman bisa mencobanya dengan mengcapture subuah halaman web dan melihat hasilnya

<?php

$html = file_get_contents('http://www.contoh.org/example.html');

preg_match_all('@<(strong|em)>(.+?)</\1>@is', $html, $matches);

foreach ($matches[2] as $text) {

    print "Text: $text \n";

}

?>

Program di atas akan menampilkan semua string yang mempunyai attribut seperti strong, atau em, teman-teman bisa menambahkan regex yang lain, seperti i untuk italic, atau b untuk bold

<?php

$html = '<link rel="icon" href="http://www.example.com/icon.gif"/>

<link rel="prev" href="http://www.example.com/prev.xml"/>

<link rel="next" href="http://www.example.com/next.xml"/>';

preg_match_all('/rel="(prev|next)" href="([^"]*?)"/', $html, $bothMatches);

preg_match_all('/rel="(?:prev|next)" href="([^"]*?)"/', $html, $linkMatches);

print '$bothMatches is: '; var_dump($bothMatches);

print '$linkMatches is: '; var_dump($linkMatches);

?>

<?php

$html = '<link rel="icon" href="http://www.example.com/icon.gif"/>

<link rel="prev" title="Previous" href="http://www.example.com/prev.xml"/>

<link rel="next" href="http://www.example.com/next.xml"/>';

preg_match_all('/rel="(?:prev|next)"(?: title="[^"]+?")? href="([^"]*?)"/', $html, $linkMatches);

print '$bothMatches is: '; var_dump($linkMatches);

?>

FUNGSI STRING PHP

2012-06-01T16:24:00.004+07:00

Dalam pembuatan program pasti kita sering berurusan dengan string atau teks, entah kita ingin mengambil hanya beberapa atau semua bagian dari teks tersebut atau langsung dimanipulasi hasilnya. Sekarang akan dicontohkan bagaimana memanipulasi huruf besar dan kecil pada string di PHP, contoh hutomo kaspar diganti menjadi Hutomo Kaspar.
Menggunakan ucfirst() atau ucwords() untuk membuat huruf depan dari kata atau kata – kata menjadi kapital:

ucfirst("malang kota dingin dan asri");

print ucwords("batu kota wisata");

Hasil:
Malang kota dingin dan asri
Batu Kota Wisata
Menggunakan strtolower() atau strtoupper untuk mengubah seluruh teks menjadi besar atau
kecil:

print strtoupper("halo apa kabar?");

// Tag harus lowercase/kecil supaya sesuai dengan standar XHTML.

print strtolower('<A HREF="elang.php">elang</A>');

hasil:
HALO APA KABAR!
<a href=”elang.php”>elang</a>

Gunakan ucfirst() untuk membuat huruf pertama menjadi kapital:

print ucfirst('sungguh ria');

print ucfirst('7 kaspar');

hasil:
Sungguh ria
7 kaspar

Perhatikan pada hasil kedua hasilnya bukan “7 Kaspar”
Gunakan ucwords() untuk membuat huruf pada setiap kata menjadi kapital:
Use ucwords( ) to capitalize the first character of each word in a string:

print ucwords('7 kaspar');

print ucwords("bintang tiga printing malang");

hasil:
7 Kaspar
Bintang Tiga Printing Malang

Untuk ucwords(), kata adalah karakter bukan kosong yang berurutan yang tampil setelah karakter kosong.
ucfirst() dan ucwords() tidak mengubah huruf yang bukan huruf pertama.
Fungsi strtolower() dan strtoupper() bekerja pada seluruh string, tidak hanya pada karakter individual. Semua karakter alfabet akan dibuah menjadi kecil oleh strtolower() atau menjadi besar oleh strtoupper()

BEBERAPA FUNGSI PHP

2012-06-01T16:19:00.001+07:00

Beberapa Fungsi Pengolah String

Pemograman - PHP

strlen()
Digunakan untuk menghitung jumlah karakter dalam suatu variable, syantax-nya sebagai berikut : strlen($namavariable)
contoh:
<?php
$kalimat="Belajar PHP";
$jumlah=strlen($kalimat);
print "variable string \$kalimat=$kalimat ";
print "Kalimat '$kalimat' diatas jumlah karakternya adalah $jumlah";
?>
strpos()
Berguna untuk mengetahui posisi suatu karakter pada sebuah variable string, Anda bisa menuliskannya dengan syntax berikut : strpos($namavariable_string, $karakter)
contoh:
<?php
$kalimat="Pemograman PHP";
$karakter="m";
$posisi=strpos($kalimat,$karakter);

print "Karakter '$karakter' berada pada posisi ke $posisi dalam kalimat '$kalimat' ";
?>

Fungsi untuk merubah huruf kapital
Untuk merubah huruf pada variable string menjadi besar semua, Anda dapat menggunakan fungsi: strtoupper("datastring)
Sedangkan unuk mengubah menjadi huruf kecil semua dapat mengunakan fungsi : strtolower("datastring")
contoh
<?php
$kalimat="Juara liga Indonesia 2006 adalah persik Kediri";
print "Kalimat awal adalah : ";
print "$kalimat ";
$ubah1=strtoupper($kalimat);
print "Kalimat diatas diubah menjadi huruf besar semua menjadi : ";
print "$ubah1 ";
$ubah2 = strtolower($kalimat);
print "Kalimat diatas diubah menjadi huruf kecil semua menjadi : ";
print "$ubah2 ";
?>

Jika Anda ingin merubah huruf peratama saja dalam suatu string maka bisa menggunakan fungsi berikut : ucfirst("data_string")
Untuk merubah huruf pertama saja dalam suatu kata dalam suatu string dapat menggunakan fungsi berikut : ucwords("data_string")
contoh
<?php
$kalimat= "belajar pemograman web dengan PHP";
print "Kalimat awal adalah '$kalimat' ";
$ubah1 =ucfirst($kalimat);
print "Setelah dirubah kapital huruf awalnya saja menjadi : ";
print $ubah1 ." ";
$ubah2 = ucwords($kalimat);
print "Setelah dirubah menjadi kapital perkata menjadi : ";
print $ubah2 ;
?>
Cara menghilangkan spasi dalam variable string
Jika Anda ingin mengubah posisi spasi pada suatu variable string, Anda dapat menggunakan fungsi-fungis berikut
1. rtrim("data_string"), untuk menghilangkan spasi yang ada di kanan string
2. ltrim("data_string"), untuk menghilangkan spasi yang ada di kiri string
3. trim(("data_string"), untuk menghilangkan spasi yang ada di kanan dan kiri string

Contoh penggunaan fungsi-fungsi diatas adalah sebagai berikut
<?php
$kata=" Program PHP "; // Perhatikan pada bagian awal dan akhir mengandung spasi satu ketuk
print "Kata '$kata' dengan spasi didepan dan dibelakang ";
$hilang1=ltrim($kata);
print "Dihilangkan spasi didepan menjadi : ";
print "'$hilang1' ";
$hilang2=rtrim($kata);
print "Dilihlangkan spasi dibelakang menjadi : ";
print "'$hilang2' ";
$hilang3=trim($kata);
print "Dilihlangkan spasi didepan dan dibelakang menjadi : ";
print "'$hilang3' ";

?>

Cara merubah variable string menjadi variable string baru yang diinginkan
Gunakan fungsi substr() untuk merubah variable string sesuai keinginan Anda
syntax-nya substr("data_string", posisi_awal, banyaknya_karakter)
Keterangan paramater dalam syntax substr():
data_string = adalah string kata atau kalimat atau karakter apapun berupa string yang ingin Anda rubah
posisi_awal = adalah angka(bukan huruf) yang menunjukkan pada posisi keberapa Anda ingin merubah string
banyaknya_karakter = adalah angka(bukan huruf) yang menunjukkan banyaknya karakter yang ingin Anda rubah
contoh:
<?php
$kata="abcdefgh";
print "Variable \$kata = '$kata' dirubah menjadi string baru sebagai berikut : ";
echo substr($kata, 2) . " --> menggunakan fungsi substr(\$kata, 2) ";
echo substr($kata, 3,2) . " --> menggunakan fungsi substr(\$kata, 3,2) ";
echo substr($kata, 0,6) . " --> menggunakan fungsi substr(\$kata, 0,6) ";
echo substr($kata, -3,2) . " --> menggunakan fungsi substr(\$kata, -3,2) ";
?>
Fungsi substring_count()
Berguna untuk menghitung jumlah kata(atau beberapa karakter) dalam sebuah string, syntax-nya sebagai berikut : substr_count("data_string", "karakter_yg_dicari")
untuk lebih jelasnya perhatikan contoh berikut ini :
<?php
$kalimat = "PHP merupakan bahasa pemograman web dinamis. Bahasa PHP cukup mudah dipelajari, dan PHP free";
$jumlah = substr_count($kalimat, "PHP");
print "Kalimat berikut ini '$kalimat' ";
print "Jumlah kata 'PHP' dalam kalimat diatas adalah : $jumlah";
?>untuk tambah lebih jelasnya lagi perhatikan contoh berikut ini:
<?php
$kata2=array("ex","te","xt","ek");
$lihat= "text text text text text text text text";
foreach($kata2 as $kw){
echo "Kata $kw terlihat ". substr_count($lihat,$kw) . " ";
}
?>

Membuat String Berulang
Untuk membuat string berulang, Anda bisa menggunakan fungsi berikut :str_repeat("yang_akan_ulang", banyaknya_pengulangan)
Contoh :
<?php
$ulang = str_repeat("selamat", 4);
print "Anda telah berhasil belajar PHP, $ulang";
?>
Mengganti Bagian Dari String
Untuk mamnipulasi data string kadang Anda perlu untu mengganti bagian tertentu dari string dengan nilai string lainnya. Anda dapat menggunakan fungsi berikut : str_replace("yg_diganti", "pengganti", "kalimat")
parameter yg_diganti adalah string yang akan digantikan oleh string yang menggantikan
parameter pengganti adalah string yang akan menggantikan string yang digantikan
parameter kalimat adalah string awal yang berisi kalimat asli yang nantinya akan digantikan
contoh:
<?php
$kata1="Belajar PHP sangat susah yaaa !";
$ubah= str_replace("susah", "mudah", $kata1);
print "Kalimat '$kata1' akan diganti menjadi : ";
print $ubah;
?>

Memecah String
String dapat dipecah menjadi beberapa bagian, untuk memecah string perkata Anda dapat menggukanan fungsi berikut : strtok("string_yg_akan_dipecah", "karakter_pemisah")
parameter karakter_pemisah bisa diisi dengan spasi kosong atau karakter apapun
contoh
<?php
$kalimat = "di wwww.agiptek.com ada tutorial PHP yang cukup lengkap untuk jadi rujukan bagi pemula programmer PHP";
$pecah = strtok($kalimat, " ");
while ($pecah){
print "$pecah ";
$pecah = strtok(" ");
}
?>

FUNSI SQL 2

2012-06-01T16:17:00.002+07:00

Berikut ini merupakan fungsi-fungsi yang digunakan dalam manipulasi string:

||
Menggabungkan dua string (operasi concat).
ASCII
Mengembalikan nilai ASCII suatu karakter.
CHR
Mengembalikan karakter suatu nilai ASCII.
CONCAT
Sama fungsinya dengan ||.
INITCAP
Mengubah huruf awal tiap kata menjadi huruf besar.
INSTR
Mendapatkan posisi karakter dalam suatu string.
LENGHT
Mendapatkan panjang suatu string.
LOWER
Mengubah string menjadi huruf kecil.
LPAD
Memampatkan string sampai panjang tertentu dengan manambahkan karakter di sebelah kiri.
LTRIM
Melakukan trim terhadap karakter tertentu di sebelah kiri string.
NLS_INITCAP
Melakukan fungsi INITCAP berdasarkan nilai Natural Language Support (NLS).
NLS_LOWER
Melakukan fungsi LOWER berdasarkan nilai Natural Language Support (NLS).
NLS_UPPER
Melakukan fungsi UPPER berdasarkan nilai Natural Language Support (NLS).
NLSSORT
Melakukan fungsi SORT berdasarkan nilai Natural Language Support (NLS).
REGEXP_INSTR, REGEXP_REPLACE, dan REGEXP_SUBSTR.
RPAD
Memampatkan string sampai panjang tertentu dengan manambahkan karakter di sebelah kanan.
RTRIM
Melakukan trim terhadap karakter tertentu di sebelah kanan string.
SOUNDEX
Mencari kata yang memiliki bunyi sama (mirip operator LIKE).
SUBSTR
Mengambil string dari suatu string.
TREAT
Mengubah tipe dari suatu ekspresi.
TRIM
Melakukan trim terhadap karakter tertentu di sebelah kiri dan kanan string.
UPPER
Mengubah string menjadi huruf besar.

Format penggunaan fungsi ini adalah NAMA_FUNGSI(string [, opsi])
Beberapa fungsi memiliki opsi untuk digunakan. Setelah mengetahu fungsi apa saja yang digunakan untuk memanipulasi string sekarang saatnya kita mempraktekan fungsi-fungsi tersebut. Dalam praktek ini saya akan menggunakan tabel DUAL yang merupakan tabel semu dalam ORACLE.
LOWER
Fungsi ini akan mengubah semua karakter dalam string menjadi huruf kecil.

SELECT LOWER(‘ITFROMZEROTOHERO’) AS HASIL FROM dual

CONCATNATION (|| dan CONCAT)
Dua fungsi ini sama kegunaannya, yaitu untuk menggabungkan dua string menjadi satu.

SELECT ‘IT’ || ‘ ‘ || ‘FROM’ || ‘ ‘ || ‘ZERO’ || ‘ ‘ || ‘TO’ || ‘ ‘ || ‘HERO’ AS hasil FROM dual

RPAD
Fungsi ini akan memamptkan string dengan menambahkan karakter di sebelah kanan. Bentuk umumnya adalah RPAD(string, length [, 'set']). Length merupakan panjang yanng diinginkan sedangkan ‘set’ adalah karakter yang digunakan untuk menambahkan string tersebut (bisa lebih dari 1 karakter).

SELECT RPAD(’1234′, 8, ‘*’) FROM dual

LPAD
Sama seperti RPAD, hanya untuk LPAD penambahan karakter dilakukan di sebelah kiri (dapat digunakan untuk mencetak string menjadi rata kanan, defaultnya rata kiri)

SELECT LPAD(’1234′, 8, ‘ ‘) FROM dual

LTRIM
Fungsi ini akan melakukan trim (pembuangan) karakter di sebelah kiri string. Bentuk umumnya LTRIM(string [, 'set']). ‘set’ merupakan kumpulan karakter yang akan ditrim. Cara kerjanya adalah sebagai berikut: pertama Oracle akan mencari mulai dari sebelah kiri string apakah ada karakter yang cocok dengan ‘set’, apabila ada maka karakter tersebut akan dibuang, pencarian berhenti jika Oracle menemukan karakter yang tidak sesuai dengan ‘set’. Perlu diperhatikan proses trim yang terjadi berada pada tingkat karakter, bukan string. Jika kita bermaksud melakukan trim ‘ok’ pada string ‘odol’ maka string yang dihasilkan adalah ‘dol’. Ini disebabkan pada proses pencarian Oracle pertama kali menemukan huruf ‘o’ yang termasuk dalam ‘ok’ pada string ‘odol’, sehingga huruf tersebut dihilangkan, sedangkan pencarian berikutnya Oracle menemukan huruf ‘d’ dalam string ‘dol’ yang tidak ada dalam ‘ok’ sehingga proses berhenti. Jadi ingat, yang ditrim adalah karakter BUKAN kata. Urutan karakter dalam ‘set’ tidak berpengaruh dalam hasil, ‘ok’ dan ‘ko’ akan menghasilkan hal yang sama. Tetapi huruf kecil dan huruf besar berpengaruh, INGAT Oracle akan memperlakukan data secara case sensitif. Sehingga ‘ok’ dan ‘OK’ akan memberikan hasil yang berbeda. Apabila opsi ‘set’ tidak dipakai, yang ditrim adalah spasi.

SELECT LTRIM(‘odol’, ‘ok’) FROM dual
SELECT LTRIM(‘odol’, ‘Ok’) FROM dual

RTRIM
Sama saja cara kerjanya seperti LTRIM hanya RTRIM akan melakukan trim di sebelah kanan string.

SELECT RTRIM(‘itfromzerotohero’, ‘ok’) FROM dual

TRIM
Fungsi ini akan melakukan trim dikiri dan kanan string. Cara kerja sama seperti fungsi LTRIM dan RTRIM. Yang berbeda hanya bentuk umumnya dan karakter ‘set’ yang digunakan HANYA boleh satu.

SELECT TRIM(‘i’ FROM ‘itfromzerotohero’) FROM dual

Fungsi TRIM memiliki dua variasi, yaitu leading (mirip dengan LTRIM) serta trailing (mirip dengan RTRIM).

SELECT TRIM(leading ‘i’ FROM ‘itfromzerotohero’) FROM dual
SELECT TRIM(trailing ‘o’ FROM ‘itfromzerotohero’) FROM dual

LOWER, UPPER, INITCAP
Fungsi LOWER akan mengubah string menjadi huruf kecil. Fungsi UPPER akan mengubah string menjadi huruf besar. Fungsi INITCAP akan mengubah huruf pertama setiap kata menjadi huruf besar.

SELECT LOWER(‘itFromzeroToherO’) FROM dual
SELECT UPPER(‘itfromzerotohero’) FROM dual
SELECT INITCAP(‘it from zero to hero’) FROM dual

LENGTH
Fungsi LENGTH hanya menampilkan informasi berapa panjang string yang dimasukan. Fungsi ini biasanya dijadikan masukan bagi fungsi yang lainnya. Sebagai catatan, kita tidak dapat menggunakan fungsi ini untuk data bertipe LONG.

SELECT LENGTH(‘it from zero to hero’) FROM dual

SUBSTR
Mungkin inilah fungsi yang paling sering digunakan. Fungsi ini berguna jika kita ingin mengambil string dari dalam string. Bentuk umumnya adalah SUBSTR(string , start [, count]). start merupakan posisi awal pemotongan string, sedangkan opsi count akan menentukan berapa banyak karakter yang diambil mulai posisi start. Jika opsi tidak ditulis maka karakter akan diambil mulai dari start hingga karakter terakhir. Apabilai nilai start negatif, maka perhitungan posisi dilakukan mulai dari belakang. Perlu diperhatikan penggunaan start dengan bilangan negatif hanya diperuntukan untuk data bertipe VARCHAR2, JANGAN digunakan untuk data bertipe CHAR. Hal ini disebabkan Oracle selalu menambahkan spasi terhadap data bertipe CHAR jika panjangnya kurang dari panjang yang didefinisikan. Jika start bernilai negatif digunakan oleh SUBSTR dengan data bertipe CHAR maka perhitungannya dilakukan relatif dari akhir string hasil penambahan spasi oleh Oracle, bukan dari string aslinya.

SELECT SUBSTR(’123456789′ , 3) FROM dual
SELECT SUBSTR(’123456789′ , 3, 4) FROM dual
SELECT SUBSTR(’123456789′ , -4) FROM dual
SELECT SUBSTR(’123456789′ , -4, 2) FROM dual

INSTR
Fungsi ini akan mengembalikan posisi karakter yang dicari dalam suatu string. Sama seperti LENGTH, fungsi ini biasanya digunakan bersama dengan fungsi yang lain. Bentuk umumnya adalah INSTR(string, set [, start [, occurence]]). set merupakan karakter yang dicari posisinya, bisa lebih dari satu karakter. Posisi yang dikembalikan adalah posisi karakter yang pertama kali ditemukan. Misal kita ingin mengetahui posisi ‘el’ dalam string ‘hellohello’, maka yang dihasilkan adalah 2, karena pencarian akan menemukan huruf ‘e’ yang merupakan huruf pertama dari ‘el’ pada string ‘hellohello’ di posisi dua.

SELECT INSTR(‘itfromzerotohero’ , ‘o’) FROM dual

Opsi start digunakan untuk menentukan awal mulai pencarian, defaulnya pada awal string. Sedangkan opsi kedua yaitu occurence digunakan untuk menentukan karakter keberapa yang cocok, defaultnya posisi yang dikembalikan adalah karakter pertama yang cocok.

SELECT INSTR(‘itfromzerotohero’ , ‘o’, 5) FROM dual
SELECT INSTR(‘itfromzerotohero’ , ‘o’, 6) FROM dual
SELECT INSTR(‘hellohello’, ‘el’, 1, 2) FROM dual

ASCII, CHR
Fungsi ASCII akan mengembalikan karakter dari nilai ascii yang dimasukan. Jika yang dimasukan adalah string maka hanya karakter pertama yang akan dihitung. Sedangkan CHR adalah kebalikannya.

SELECT ASCII(‘A’) FROM dual
SELECT ASCII(‘Ada’) FROM dual
SELECT CHR(65) FROM dual

SOUNDEX
Fungsi ini kegunaannya lebih mirip dengan clausa WHERE dengan menggunakan operator LIKE. Sebagai contoh kita akan gunakan untuk menampilkan data pekerjaan yang mirip dengan ‘presiden’. SOUNDEX akan membuat asumsi bagaimana kombinasi huruf dieja dalam bahasa Inggris, dan kedua kata yang dibandingkan harus dimulai dengan huruf yang sama. SOUNDEX dapat dipakai untuk membandingkan data dari dua kolom yang sekiranya memiliki kemiripan bunyi.

SELECT job_title FROM jobs WHERE SOUNDEX(job_title) = SOUNDEX(‘presiden’)

Fungsi-fungsi di atas biasanya kita gunakan dalam melakukan filtering data, yaitu pada clausa WHERE. Contoh-contoh yang saya berikan selalu menggunakan tabel semu dual untuk menyederhanakan tutorial. Penggunaan umumnya data tidak langsung berupa literal string melainkan berupa data yang diambil dari kolom. Untuk itu literal string dapat digantikan dengan nama kolom, tentunya tanpa tanda petik satu. Silahkan bereksperimen dengan fungsi-fungsi manipulasi string ini, sebab tiap fungsi dapat dikombinasikan untuk mendapatkan hasil yang lebih banyak.

FUNGSI-FUNGSI PADA MYSQL

2012-06-01T16:15:00.002+07:00

ASCI(x)

Fungsi ini digunakan untuk menghasilkan kode ASCII dari karakter pertama dalam suatu string x.
Contoh: Select ASCII('n');
Hasil: 110
Contoh: Select ASCII('N');
Hasil: 78

------------------------------------------

CHAR(x, y, z, ...)

Fungsi ini dapat menghasilkan nilai string berdasarkan daftar kode ASCII yang dijadikan parameter dalam fungsi.
Contoh: Select CHAR(65, 66, 40, 70);
Hasil: AB(F

------------------------------------------

CHARACTER_LENGTH, CHAR_LENGTH

Pembahasan sama dengan LENGTH()

------------------------------------------

COALESCE(ekspresi1, ekspresi2, ...)

Fungsi ini dapat menghasilkan data yang bukan NULL yang pertama kali dari daftar ekspresi yang menjadi argumen dalam parameter. Ekspresi dapat berupa data null, string, numerik ataupun tanggal.
Contoh: Select COALESCE(NULL, 'Payah', 372);
Hasil: Payah

------------------------------------------

CONCAT(x, y, z, ...)

Fungsi ini dapat menggabungkan beberapa string yang menjadi parameter. Tetapi jika ada nilai NULL dalam parameter string, maka hasil dari CONCAT adalah NULL.
Contoh: Select CONCAT('Satu', '2', 'Tiga');
Hasil: Satu2Tiga
Contoh: Select CONCAT('Satu', null, 'Tiga');
Hasil: (NULL)

------------------------------------------

DECODE(string_biner, string_ekspresi)

Mengembalikan nilai string biner yang di enkripsi, string enkripsi yang digunakan harus sama dengan string yang digunakan pada saat mengenkripsi. Fungsi ini merupakan kebalikan dari fungsi ENCODE().
Contoh: Select DECODE('Kambing', 'Mamalia');
Hasil: JF

------------------------------------------

ELT(x, a, b, c, ...)

Menghasilkan string pada posisi x dari daftar argumen yang menjadi parameter a, b, c, ...
Contoh: Select ELT(2, 'Panji', 'Dapur', 'Wempi');
Hasil: Dapur

------------------------------------------

ENCODE(word, string_enkripsi)

Fungsi ini berguna untuk mengenkripsi suatu string word menggunakan kata sandi. Hasilnya adalah string biner yang telah dienkripsi.
Contoh: Select ENCODE('Kambing', 'Mamalia'), DECODE(ENCODE('Kambing', 'Mamalia'), 'Mamalia');
Hasil: 4>'M2
Hasil: Kambing

------------------------------------------

ENCRYPT(word[,seed])

Fungsi ini juga berfungsi untuk mengenkripsikan suatu string dengan kata sandi seed dalam 2 huruf, menggunakan fungsi crypt Unix. Fungsi ini menghasilkan string yang terinkripsi dan NULL jika dilakukan pada system operasi yang tidak memiliki fungsy crypt seperti MS Windows.
Contoh: Select ENCRYPT('Kambing', 'Ma');
Hasil: (NULL) *di Windows XP

------------------------------------------

FIELD(x, a, b, ...)

Fungsi ini untuk menentukan posisi dari string x dalam daftar argumen a, b, ...
Contoh: Select FIELD('Kambing', 'Kerbau', 'Sapi', 'Wempi', 'Kambing', 'Unta');
Hasil: 4

------------------------------------------

FIND_IN_SET(x, stringlist)

Mirip dengan fungsi FIELD(x, a, b, ...). Hanya saja stringlist merupakan kelompok string yang dicari dipisah menggunakan koma tanpa spasi.
Contoh: Select FIND_IN_SET('Kambing', 'Kerbau,Sapi,Wempi,Kambing,Unta');
Hasil: 4

------------------------------------------

INSERT(x, y, z,j)

Fungsi ini menghasilkan string x yang telah diganti isinya dengan string j mulai posisi ke y sebanyak z.
Contoh: Select INSERT('Wemsatria', 4, 2, 'Pisang');
Hasil: WemPisangtria

------------------------------------------

INSTR(x, y)

Fungsi ini merupakan kebalikan dari fungsi LOCATE(x, y) dan POSITION(x, y). Fungsi ini dapat menghasilkan nilai posisi string y di dalam string x.
Contoh: Select INSTR('Wempi adalah te_no_net NoksPi Satria', 'te_no_net');
Hasil: 14

------------------------------------------

LCASE(x)

Fungsi ini berguna untuk menjadikan semua karakter dalam string x menjadi tulisan dalam huruf kecil semua (lowercase).
Contoh: Select LCASE('Wempi Satria');
Hasil: wempi satria

------------------------------------------

LEFT(x, y)

Fungsi ini untuk mengambil sejumlah y karakter dari string x, mulai dari posisi awal.
Contoh: Select LEFT('Wempi Satria', 5);
Hasil: Wempi

------------------------------------------

LENGTH(x)

Untuk mengetahui panjang string x, kita dapat menggunakan fungsi ini.
Contoh: Select LENGTH('Wempi Satria');
Hasil: 12

------------------------------------------

LOCATE(x, y, z)

Untuk mengetahui posisi string x di dalam string y mulai dari posisi ke z.
Contoh: Select LOCATE('m', 'Wempi', 2);
Hasil: 3

------------------------------------------

LOWER(x)

Fungsi ini sama denga fungsi LCASE(x).

------------------------------------------

LPAD(x, y, z)

Digunakan untuk menambahkan string z kepada string x di sebelah kiri apabila panjang string x lebih kecil dari y)
Contoh: Select LPAD('Satria', 12, 'We');
Hasil: WeWeWeSatria

------------------------------------------

LTRIM(x)

Berguna untuk menghilangkan spasi di sebelah kanan string x.
Contoh: Select LTRIM(' Wempi Satria' );
Hasil: Wempi Satria

------------------------------------------

MID(x, y, z)

Mengambil string x sebanyak z dimulai dari posisi ke y.
Contoh: Select MID('Wempi Satria', 4, 6);
Hasil: pi Sat

------------------------------------------

OCTET_LENGTH()

Lihat pembahasannya di fungsi LENGTH().

------------------------------------------

PASSWORD(password)

Menghasilkan string password yang disandikan.
Contoh: Select PASSWORD('Wempi');
Hasi: *D4978643D6FD18E46D01128734C1081A976DE812

------------------------------------------

POSITION(x IN y)

Menghasilkan awal posisi dari string x yang pertama kali ditemukan dalam string y. Hasil 0 jika tidak ditemukan.
Contoh: Select POSITION('Satria' IN 'Wempi Satria');
Hasil: 6

------------------------------------------

REPEAT(x, y)

Menghasilkan string x yang diulang sebayak y kali.
Contoh: Select REPEAT('Wempi', 5);
Hasil: WempiWempiWempiWempiWempi

------------------------------------------

REPLACE(x, y, z)

Mengganti semua string y yang ditemukan dalam string x menggunakan string z.
Contoh: Select REPLACE('Wempi Satria', 'i', 'e');
Hasil: Wempe Satrea

------------------------------------------

REVERSE(x)

Membalikkan urutan penulisan string x.
Contoh: Select REVERSE('Wempi Satria');
Hasil: airtaS ipmeW

------------------------------------------

RIGHT(x, y)

Mengambil y karakter dari string x dimulai dari posisi paling kanan (akhir).
Contoh: Select RIGHT('Wempi Satria', 4);
Hasil: tria

------------------------------------------

RPAD(x, y, z)

Menambahkan string z di sebelah kanan string x jika panjang string x lebih kecil dari y.
Contoh: Select RPAD('Wempi', 12, 'Sat');
Hasil: WempiSatSatS

------------------------------------------

RTRIM(x)

Membuang semua spasi yang ada di sebelah kanan string x.
Contoh: Select RTRIM(' Wempi Satria' );
Hasil: Wempi Satria

------------------------------------------

SOUNDEX(x)

Menghasilkan sebuah string soundex dari string x.
Contoh: Select SOUNDEX('Wempi Satria');
Hasil W51236

------------------------------------------

SPACE(x)

Membuat string spasi sebanyak x.
Contoh: Select SPACE(10);
Hasil: " "

------------------------------------------

STRCMP(string1, string2)

Digunakan untuk menmbanding 2 buah string, jika jumlahnya sama akan diberi nilai 0, jika string1 string2 akan diberi nilai 1.
Contoh: Select STRCMP('Wempi Satria', 'wempi satria');
Hasil: 0

------------------------------------------

SUBSTRING_INDEX(x, y, z)

Digunakan untuk mendapatkan semua string x, setelah string y sebanyak z kali ditemukan. Jika z bernilai positif maka pointer bergerak dari kiri ke kanan dan sebaliknya.
Contoh: Select SUBSTRING_INDEX('Wempi Satria', 'i', 1);
Hasil: Wemp

------------------------------------------

TRIM([[BOTH or LEADING or TRAILING][x]FROM]y)

LEADING digunakan untuk membuang string x dari depan string y. TRAILING digunakan untuk membuang string x dari belakang string y. BOTH digunakan untuk membuang string x di depan dan belakang string y.
Contoh: Select TRIM('Wempi Satria'); Select TRIM(LEADING 'Wempi' FROM 'Wempi Satria'); Select TRIM(BOTH 'Wempi' FROM 'Wempi Satria Wempi');
Hasil: Wempi Satria; Satria; Satria

------------------------------------------

UCASE(x)

Fungsi ini dapat mengubah string x menjadi huruf kapital semua.
Contoh: Select UCASE('Wempi Satria');
Hasil: WEMPI SATRIA

------------------------------------------

UPPER(x)

Fungsi ini sama dengan fungsi UCASE(x)

------------------------------------------

Selanjutnya kita akan membahas tentang Fungsi MySQL [Date - Time]. Dan baca juga tulisan sebelumnya dengan judul Fungsi MySQL [Aritmetika] - Built In.

Untitled

Select CHAR(65, 66, 40, 70);

FUNGSI-FUNGS PADA SQL ORRACLE

2012-06-01T16:05:00.001+07:00

4.1.2. CONCAT(column|expression1, column|expression2)
Fungsi CONCAT() digunakan untuk menggabungkan column atau expression. Fungsi ini sama dengan operator penggabungan (||). Perhatikan contoh berikut ini:
SELECT CONCAT(’Indra’, ‘ Armansyah’) “Name”
FROM dual;
SELECT CONCAT(first_name, CONCAT(’ ‘, last_name)) “Employee Name”
FROM employee;
4.1.3. INITCAP(column|expression)
Fungsi INITCAP() digunakan untuk mengkonversi huruf awal yang terdapat pada suatu column atau expression menjadi huruf kapital (huruf besar). Perhatikan contoh berikut ini:
SELECT INITCAP(’indra armansyah’) “Initcap”
FROM dual;
Initcap
Indra Armansyah
4.1.4. LENGTH(column|expression)
Fungsi LENGTH() digunakan untuk menghitung panjang dari column atau expression. Perhatikan contoh berikut ini:
SELECT LENGTH(’Indra Armansyah’) “Length”
FROM dual;
Length
15
4.1.5. LOWER(column|expression)
Fungsi LOWER() digunakan untuk mengkonversi nilai-nilai yang terdapat pada column atau expression menjadi huruf kecil. Perhatikan contoh berikut ini:
SELECT LOWER(’INDRA ARMANSYAH’) “Lowercase”
FROM dual;
Lowercase
indra armansyah
4.1.6. UPPER(column|expression)
Fungsi UPPER() digunakan untuk mengubah untuk mengkonversi nilai-nilai yang terdapat pada column atau expression menjadi huruf besar. Perhatikan contoh berikut ini:
SELECT UPPER(’indra armansyah’) “Uppercase”
FROM dual;
Uppercase
INDRA ARMANSYAH
4.1.7. NVL(column|expression1, column|expression2)
Fungsi NVL() digunakan untuk mengkonversi nilai null baik dari suatu column maupun expression menjadi sebuah nilai baru yang kita inginkan. Perhatikan contoh berikut ini:
SELECT id, last_name “Name”, NVL(commission_pct,0) “Commission”
FROM employee;
4.1.8. SUBSTR(column|expression, m, [n])
Fungsi SUBSTR() digunakan untuk mengambil n karakter dari column|expression dimulai dari karakter ke-m. Perhatikan contoh berikut ini:
SELECT SUBSTR(’Indra Armansyah’,1,5) “Substr”
FROM dual;
Substr
Indra
SELECT SUBSTR(’Indra Armansyah’,-9) “Substr”
Substr
Armansyah
4.1.9. REPLACE(column|expression1, expression2, expression3)
Fungsi REPLACE() digunakan untuk mengganti suatu string yang terkandung pada suatu string lain menjadi sebuah string baru yang kita inginkan. Perhatikan contoh berikut ini:
SELECT REPLACE(’20-JUL-2002′,’2002′,’1902′) “Replace”
FROM dual;
Replace
20-JUL-1902
Pada contoh diatas kita mengganti string ‘2002′ yang terkandung di dalam ‘20-JUL-2002′ menjadi ‘1902′ sehingga hasilnya menjadi ‘20-JUL-1902′.
4.2. Fungsi Angka
4.2.1. ROUND(column|expression[,n])
Fungsi ROUND digunakan untuk membulatkan nilai column atau expression sebanyak n desimal di belakang koma. Perhatikan contoh berikut ini:
SELECT ROUND(19.74,1) “Round 1″, ROUND(19.75,1) “Round 2″
FROM dual;
Round 1 Round 2
19.7 19.8
4.2.2. TRUNC(column|expression[,n])
Fungsi TRUNC() digunakan untuk membulatkan kebawah atas nilai column atau expression sebanyak n desimal di belakang koma. Perhatikan contoh berikut ini:
SELECT TRUNC(19.74,1) “Trunc 1″, TRUNC(19.75,1) “Trunc 2″
FROM dual;
Trunc 1 Trunc 2
19.7 19.7
4.2.3. MOD(m,n)
Fungsi MOD() digunakan untuk menampilkan sisa pembagian antara m dan n. Fungsi ini menghasilkan m jika n adalah 0. Perhatikan contoh berikut ini
SELECT MOD(3,2), MOD(3,0)
FROM dual;
MOD(3,2) MOD(3,0)
1 3
4.2.4. POWER(m,n)
Fungsi POWER() digunakan untuk menampilkan hasil m pangkat n. Perhatikan contoh berikut ini:
SELECT POWER(3,2)
FROM dual;
POWER(3,2)
9
4.3. Fungsi Tanggal
4.3.1. MONTHS_BETWEEN(date1, date2)
Fungsi MONTHS_BETWEEN() digunakan untuk menghitung selisih bulan antara date1 dan date2. Perhatikan contoh berikut ini:
SELECT MONTHS_BETWEEN(sysdate,’01-OCT-02′)
FROM dual;
4.3.2. ADD_MONTHS(date, n)
Fungsi ADD_MONTHS() digunakan untuk menambahkan n bulan terhadap date. Perhatikan contoh berikut ini:
SELECT ADD_MONTHS(’01-OCT-02′,2)
FROM dual;
4.3.3. NEXT_DAY(date,’char’)
Fungsi NEXT_DAY() digunakan untuk mencari tanggal dari hari pertama (char) setelah date. Perhatikan contoh berikut ini:
SELECT NEXT_DAY(’01-OCT-02′,2)
FROM dual;
4.3.4. LAST_DAY(date)
Fungsi LAST_DAY() digunakan untuk mencari tanggal terakhir dari bulan date. Perhatikan contoh berikut ini:
SELECT LAST_DAY(’01-OCT-01′)
FROM dual;
LAST_DAY(
31-OCT-01
Perhatikan bahwa tanggal terakhir dari bulan October adalah 31-OCT-01.
Oracle Magazine contains technology strategy articles, sample code, tips, Oracle and partner news, how to articles for developers and DBAs, and more. Oracle (NASDAQ: ORCL) is the world’s largest enterprise software company.

For more information about Oracle, please visit their Web site at http://www.oracle.com. Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners.

Get Free Oracle Magazine

4.3.5. ROUND(date[,’fmt’])
Fungsi ROUND() digunakan untuk membulatkan date. Jika fmt tidak disebutkan maka akan dibulatkan ke hari terdekat. Perhatikan contoh berikut ini:
SELECT ROUND(TO_DATE(’27-OCT-92′),’YEAR’) “Round Date”
FROM dual;
Round Date
01-JAN-93
4.3.6. SYSDATE
Fungsi SYSDATE digunakan untuk menampilkan tanggal dan jam sistem. Perhatikan contoh berikut ini:
SELECT SYSDATE “Today”
FROM dual;
4.3.7. TRUNC(date[,’fmt’])
Fungsi TRUNC() digunakan untuk membulatkan date. Jika fmt tidak disebutkan maka akan dibulatkan ke hari terdekat. Perhatikan contoh berikut ini:
SELECT TRUNC(TO_DATE(’27-OCT-92′),’YEAR’) “Trunc Date”
FROM dual;
Trunc Date
01-JAN-92
4.4. Fungsi Konversi
4.4.1. TO_CHAR(number|date[,’fmt’])
Fungsi TO_CHAR() digunakan untuk mengkonversi data bertipe number atau date menjadi karakter. Perhatikan contoh berikut ini:
SELECT TO_CHAR(sysdate,’DD MONTH YYYY’)
FROM dual;
Jika kita asumsikan bahwa tanggal sistem adalah 01-OCT-01 maka hasil query adalah sebagai berikut:
TO_CHAR(SYSDATE,’
01 OCTOBER 2001
4.4.2. TO_DATE(char[,’fmt’])
Fungsi TO_DATE() digunakan untuk mengkonversi data bertipe karakter menjadi tanggal. Perhatikan contoh berikut ini:
SELECT TO_DATE(’01-OCT-02′,’DD-MON-YY’)
FROM dual;
TO_DATE(’
01-OCT-02
Fungsi TO_DATE berguna jika kita ingin menginputkan data atau mencari berdasarkan data bertipe tanggal, namun format tanggal yang kita miliki berbeda dengan format default yang ada (DD-MON-YY). Penjelasan lengkap dapat diikuti pada bagian Interpretasi Tanggal.
4.4.3. TO_NUMBER(char)
Fungsi TO_NUMBER() digunakan untuk mengkonversi data bertipe karakter menjadi angka. Perhatikan contoh berikut ini:
SELECT TO_NUMBER(’5′) * 5
FROM dual;
TO_NUMBER(’5′)*5
25
4.5. Fungsi Lain
4.5.1. GREATEST(expr1[,expr2]…)
Fungsi GREATEST() digunakan untuk mencari nilai terbesar dari beberapa expression. Perhatikan contoh berikut ini:
SELECT GREATEST(’HARRY’,'HARRIOT’,'HAROLD’) “Greatest”
FROM dual;
GREAT
HARRY
4.5.2. LEAST(expr1[,expr2]…)
Fungsi LEAST() digunakan untuk mencari nilai terkecil dari beberapa expression. Perhatikan contoh berikut ini:
SELECT LEAST(’HARRY’,'HARRIOT’,'HAROLD’) “Least”
FROM dual;
LEAST
HAROLD
4.5.3. USER
Fungsi USER digunakan untuk menampilkan nama user yang sedang terkoneksi dengan database Oracle. Perhatikan contoh berikut ini:
SELECT USER, UID
FROM dual;

USER	UID
INDRA	2367

4.5.4. USERENV(option)
Fungsi USERENV() digunakan untuk menampilkan environment pengguna. Perhatikan contoh berikut ini:
SELECT USERENV(’LANGUAGE’) “Language”, USERENV(’TERMINAL’) “Terminal”
FROM dual;

Language	Terminal
AMERICAN_AMERICA.WE8MSWIN1252	HASTINAPURA

4.5.5. VSIZE()
Fungsi VSIZE(expr) digunakan untuk menampilkan jumlah byte dalam representasi internal dari expr.
SELECT last_name “Name”, VSIZE(last_name) “Bytes”
FROM employee;

Name	Bytes
Velasquez	9
Ngao	4
Nagayama	8

Interpretasi Tanggal

Kita perlu berhati-hati jika bekerja dengan data bertipe tanggal, karena Oracle menginterpretasikan tahun sesuai dengan tahun pada tanggal sistem.

Data	Tahun Sistem	Interpretasi
01-OCT-01	>=2000	01-OCT-2001
01-OCT-01	< 2000	01-OCT-1901

Perhatikan contoh berikut:
CREATE TABLE tanggal( tanggal DATE );
Pastikan berapa sesungguhnya tahun sistem sekarang dengan menggunakan fungsi TO_CHAR. Kemudian satu data ke dalam tabel TANGGAL, tahun yang kita maksud disini adalah 1974, bukan 2074.
INSERT INTO tanggal VALUES(‘01-OCT-74′);
SELECT TO_CHAR(TANGGAL,’DD-MON-YYYY’)
FROM coba;
TANGGAL
01-OCT-2074
Oracle menginterpretasikan tahun 74 yang kita inputkan menjadi 2074 bukannya 1974. Mengapa demikian? Perhatikan kembali penjelasan pada tabel mengenai interpretasi tanggal.
Kita dapat menggunakan dua alternatif pemecahan untuk mengatasi permasalahan ini:

Mengubah tanggal sistem dari sistem operasi sehingga memiliki tahun < 2000 (tidak disarankan)
Menggunakan fungsi TO_DATE

Pada dasarnya kita harus memberitahukan kepada Oracle dengan jelas berapa sesungguhnya tahun yang kita maksud, 1974 atau 2074, agar data dapat diinterpretasikan dengan benar. Perhatikan perintah insert yang sudah dimodifikasi berikut:
INSERT INTO tanggal VALUES(TO_DATE(‘01-OCT-1974′,’DD-MON-YYYY’);
SELECT TO_CHAR(TANGGAL,’DD-MON-YYYY’)
FROM tanggal;
TANGGAL
01-OCT-1974
Format Tanggal
SCC atau CC : Abad.
YYYY atau SYYYY : Tahun dalam empat digit.
YYY atau YY atau Y : Tiga, dua, atau satu digit terakhir dari tahun.
Y,YYY : Tahun dengan koma pada posisi tersebut.
SYEAR atau YEAR : Tahun dalam ejaan.
Q : Kwartal dari tahun.
MM : Bulan dalam dua digit.
MONTH : Bulan dalam ejaan.
MON : Bulan dalam ejaan tiga huruf.
RM : Bulan dalam angka romawi.
WW atau W : Minggu ke sekian dalam tahun yang bersangkutan, dalam dua atau satu digit.
DDD atau DD atau D : Hari ke sekian dalam tahun, bulan atau minggu yang bersangkutan.
DAY : Hari dalam ejaan.
DY : Hari dalam ejaan tiga huruf.
Format Waktu
AM atau PM (A.M. atau P.M.) : Indikator meridian.
HH atau HH12 atau HH24 : Jam kesekian dalam hari yang bersangkutan, jam(1 - 12), atau jam (0 - 23)
MI : Menit (0 - 59).
SS : Detik (0 - 59).
SSSSS : Detik ke sekian setelah tengah malam (0 - 86399).
Format Lain
/ . , : Memisahkan hasil konversi sesuai tampilan yang diinginkan.
” of the ” : Menambahkan karakter string ke dalam tampilan hasil konversi.
Akhiran
TH : Menampilkan urutan nomor (contoh, DDTH untuk 4 TH).
SP : Nomor dalam ejaan (contoh, DDSP untuk FOUR)
SPTH atau THSP : Menampilkan urutan nomor dalam ejaan (contoh, DDSPTH untuk FOURTH).
Format Angka
9 : Posisi numerik (jumlah angka 9 menunjukkan maksimal panjang data yang dapat ditampilkan). Contoh 999999 untuk hasil 1234
0 : Menambahkan awalan 0. Contoh 099999 untuk hasil 01234
$ : Menambahkan awalan dollar. Contoh $999999 untuk hasil $1234
L : Menambahkan simbol local currency. Contoh L999999 untuk hasil L1234
. : Menambahkan titik pada posisi tertentu. Contoh 999999.99 untuk hasil 1234.00
, : Menambahkan koma pada posisi tertentu. Contoh 999,999 untuk hasil 1,234
MI : Menambahkan tanda negatif di sebelah kanan angka. Contoh 999999MI
untuk hasil 1234-
PR : Contoh 999999PR untuk hasil <1234>
EEEE : Notasi untuk operasi scientific. Contoh 99.999EEEE untuk hasil 1,234E+03
V : Mengalikan dengan 10 n kali (n menunjukkanjumlah angka 9 setelah V). Contoh 9999V99 untuk hasil 123400
B : Menampilkan nilai nol sebagai blank. Contoh B9999,99 untuk hasil 1234,00
4.6. Latihan
Tampilkan nama lengkap pegawai dengan huruf kecil, inisial pegawai dengan huruf depan kapital, dan jabatan pegawai dengan huruf kapital, khusus untuk pegawai dengan jabatan vice president. Tampilkan nama lengkap pegawai dengan judul VP, inisial pegawai dengan judul USERID, dan jagatan pegawai dengan judul TITLE.
SELECT LOWER(first_name | | ‘ ‘ | | last_name) VP, INITCAP(userid) USERID, UPPER(title) TITLE
FROM employee
WHERE title LIKE ‘VP%’;
Tampilkan nama depan dan nama belakang pegawai yang memiliki nama belakang PATEL.
SELECT first_name, last_name
FROM employee
WHERE UPPER(last_name) = ‘PATEL’;
Tampilkan nama dan negara pelanggan dengan nilai kredit GOOD. Tampilkan nama dan negara pelanggan dalam satu kolom dipisahkan spasi, beri judul CUSTOMER.
SELECT CONCAT(name, country) CUSTOMER
FROM customer;
Tampilkan nama produk dan panjang dari nama produk tersebut untuk produk yang tiga huruf pertamanya adalah “Ace”.
SELECT name, LENGTH(name)
FROM product
WHERE SUBSTR(name,1,3) = ‘Ace’;
Tampilkan nama produk dan panjang dari nama produk tersebut untuk produk yang tiga huruf terakhirnya adalah “Bar”.
SELECT name, LENGTH(name)
FROM product
WHERE SUBSTR(name,-3) = ‘Bar’
Ketikkan perintah berikut ini dan amatilah hasilnya.
SELECT ROUND(45.923,2), ROUND(45.923,1), ROUND(45.923,0), ROUND(45.923,-1), ROUND(45.923,-2)
FROM SYS. DUAL;
Ketikkan perintah berikut ini dan amatilah hasilnya.
SELECT TRUNC(45.923,2), TRUNC(45.923,1), TRUNC(45.923,0), TRUNC(45.923,-1), TRUNC(45.923,-2)
FROM SYS. DUAL;
Tampilkan nama belakang, jabatan pegawai dan kode departemen dimana pegawai tersebut bekerja khusus untuk pegawai yang bekerja pada departemen dengan kode genap.
SELECT last_name, title, dept_id
FROM employee
WHERE MOD(dept_id,2) = 0;
Tampilkan tanggal sistem.
SELECT sysdate
FROM sys.dual;
Tampilkan nama belakang dan masa kerja pegawai yang bekerja pada departemen dengan kode 43, dengan ketentuan bahwa masa kerja adalah tanggal sejak pegawai tersebut bekerja hingga sekarang. Tampilkan masa kerja tersebut dalam hitungan minggu dan beri judul dengan WEEKS. Tampilkan urut berdasarkan nama belakang pegawai.
SELECT last_name, (SYSDATE - start_date) / 7 WEEKS
FROM employee
WHERE dept_id = 43;
Tampilkan kode pegawai, tanggal pegawai tersebut mulai bekerja, lama pegawai tersebut bekerja hingga sekarang dalam hitungan bulan dengan judul TENURE, dan enam bulan berikut sejak pegawai tersebut bekerja dengan judul REVIEW, khusus untuk pegawai dengan masa kerja hingga sekarang lebih dari 100 bulan.
SELECT id, start_date, MONTHS_BETWEEN(SYSDATE, start_date)
TENURE, ADD_MONTHS(start_date,6) REVIEW
FROM employee
WHERE MONTHS_BETWEEN(SYSDATE, start_date) > 100;
Tampilkan kode pegawai, tanggal pegawai tersebut mulai bekerja, hari Jum’at pertama setelah tanggal pegawai tersebut mulai bekerja, dan tanggal terakhir dari bulan pegawai tersebut mulai bekerja, khusus untuk pegawai yang memiliki kode genap.
SELECT id, start_date, NEXT_DAY(start_date,’FRIDAY’), LAST_DAY(start_date)
FROM employee
WHERE MOD(id,2) = 0;
Ketikkan perintah berikut ini dan amatilah hasilnya.
SELECT id, start_date,ROUND(start_date,’MONTH’) RM, TRUNC(start_date,’MONTH’) TM,ROUND(start_date,’YEAR’) RY, TRUNC(start_date,’YEAR’) TY
FROM employee
WHERE start_date LIKE ‘%91′;
Tampilkan nomor order dan tanggal order untuk semua order yang ditangani oleh sales representative dengan kode 11. Tampilkan tanggal order dengan format MM/YY dan beri judul ORDERED.
SELECT ID, TO_CHAR(date_ordered,’MM/YY’) ORDERED
FROM orders
WHERE sales_rep_id = 11;
Tampilkan nama belakang pegawai dan tanggal pegawai tersebut mulai bekerja. Untuk tanggal pegawai mulai bekerja tampilkan dengan format sehingga akan tampak seperti 7 of February 1991 dan beri judul HIREDATE.
COLUMN HIREDATE FORMAT A50
SELECT last_name, TO_CHAR(start_date,’fmDD “of” Month YYYY’)
HIREDATE
FROM employee
WHERE start_date LIKE ‘%91′;
Tampilkan kembali soal diatas dimana tanggal pegawai mulai bekerja akan tampak seperti Sevententh of February 1991 08:00:00 AM dan beri judul HIREDATE.
SELECT last_name, TO_CHAR(start_date,’fmDdspth “of” Month YYYY
fmHH:MI:SS AM’) HIREDATE
FROM employee
WHERE start_date LIKE ‘%91′;
Tampilkan pesan yang mengindikasikan nomor dan total order, khusus untuk order yang dikirimkan pada tanggal 21 September 1992. Tampilkan dengan judul NOTE.
SELECT ‘Order ‘ | | TO_CHAR(id) | | ‘ was filled for a total of ‘ | | TO_CHAR(total,’fm$99,999,999′) NOTE
FROM orders
WHERE date_shipped = ‘21-SEP-92′;
Tampilkan nomor, total dan tanggal untuk order dengan tanggal September 7, 1992. Konversilah string tanggal pada soal ini menjadi format tanggal, sehingga dapat dilakukan pencarian terhadap data yang dimaksud.
SELECT id, total, date_ordered
FROM orders
WHERE date_ordered = TO_DATE(’7 September 1992′,’dd Month YYYY’);
Tampilkan gabungan nama belakang dan jabatan pegawai dengan judul Vice President, khusus untuk pegawai dengan jabatan vice president, dengan ketentuan nama belakang ditampilkan dengan huruf kapital. Hilangkan karakter VP pada jabatan.
SELECT CONCAT(UPPER(last_name), SUBSTR(title,3)) “Vice President”
FROM employee
WHERE title LIKE ‘VP%’;
Tampilkan nama belakang dari pimpinan perusahaan, yaitu pegawai yang tidak memiliki atasan, sehingga akan tampak seperti:
BOSS
——————————-
Velasquez has no manager
SELECT last_name | | ‘ ‘ | | ‘has no manager’ BOSS
FROM employee
WHERE manager_id IS NULL;
Tampilkan tanggal dari hari Jum’at enam bulan berikutnya setelah tanggal order. Hasilnya akan tampak seperti : Friday, March 12th, 1993. Tampilkan dengan judul New 6 Month Review, dan urutkan berdasarkan tanggal order.
SELECT TO_CHAR(NEXT_DAY(ADD_MONTHS(date_ordered,6), ‘FRIDAY’), ‘fmDay, Month ddth, YYYY’) “New 6 Month Review”
FROM orders
ORDER BY date_ordered;
Tampilkan nama belakang dan jabatan pegawai, sehingga tampak seperti berikut:
EMPLOYEE
—————————————————————-
Biri(Warehouse Manager)
Catchpole(Warehouse Manager)
……………………
SELECT last_name | | ‘(’ | | title | | ‘)’ EMPLOYEE
FROM employee
ORDER BY last_name;
Tampilkan nama belakang pegawai, tanggal pegawai tersebut mulai bekerja, tanggal peninjauan gaji pegawai yang merupakan hari Senin pertama setelah enam bulan seorang pegawai bekerja. Tampilkan tanggal peninjauan gaji dengan judul REVIEW dan dengan format seperti Eight of May 1992.
COLUMN REVIEW FORMAT A50
SELECT last_name,start_date, TO_CHAR(NEXT_DAY(ADD_MONTHS(start_date,6),
‘MONDAY’),’fmDdspth “of” Month YYYY’) REVIEW
FROM employee
ORDER BY start_date;
Tampilkan nama belakang pegawai, tanggal dan hari pegawai tersebut mulai bekerja.
COLUMN DAY FORMAT A10
SELECT last_name, start_date, TO_CHAR(start_date,’fmDAY’) DAY
FROM employee;
Tampilkan gabungan nama belakang, gaji bulanan, dan gaji impian pegawai dengan judul Dream Salaries, dengan catatan nama belakang pegawai ditampilkan dalam huruf kapital, sedangkan gaji bulanan dan gaji impian ditampilkan dalam format $99,999. Gunakan fungsi-fungsi pada latihan-latihan sebelumnya, dan tampilkan hasil query tersebut dengan format:
<last_name> earns <salary> monthly but wants <3 * salary>
Contoh : ALLEN earns $1,100 monthly but wants $3,300.
SELECT upper(last_name) | | ‘ earns ‘ | | TO_CHAR(salary,’fm$9,999′) | |
‘ but wants ‘ | | TO_CHAR(salary*3,’fm$9,999′) “Dream Salaries”
FROM employee;

SHELL SCRIPT READ XML

2012-06-01T12:28:00.000+07:00

#!/bin/bash

#Looking for four keywords in here

for key in changelog name date email

do

OUTPT=`grep  $key log.xml | tr -d '\t' | sed 's/^\([^<].*\)$/\1/' `

eval ${key}=`echo -ne \""${OUTPT}"\"`

done

# Getting the results in four specific arrays

changelogarr=( `echo ${changelog}` )

namearr=( `echo ${name}` )

datearr=( `echo ${date}` )

emailarr=( `echo ${email}` )

#Print all Arrays

echo ${changelogarr[@]}

echo ${namearr[@]}

echo ${datearr[@]}

echo ${emailarr[@]}

SECT="subsection1"
sed -n "/<$SECT>/,/<\\\\$SECT>/ p" data.xml | sed '1d;$d' >temp
while read L
do
    eval "$L"
done < temp
echo "X='$X' - Y='$Y' - Z='$Z'"