Monthly Archives: December 2007

提高mysql性能的方法!


提高mysql性能的方法!


来自:chinaunix  作者:uunguymadman007风云使者

一、问题的提出
在应用系统开发初期,由于开发数据库数据比较少,对于查询SQL语句,复杂视图的的编写等体会不出SQL语句各种写法的性能优劣,但是如果将应用系统提交实际应用后,随着数据库中数据的增加,系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据,劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍,可见对于一个系统不是简单地能实现其功能就可,而是要写出高质量的SQL语句,提高系统的可用性。

在多数情况下,Oracle使用索引来更快地遍历表,优化器主要根据定义的索引来提高性能。但是,如果在SQL语句的where子句中写的SQL代码不合理,就会造成优化器删去索引而使用全表扫描,一般就这种SQL语句就是所谓的劣质SQL语句。在编写SQL语句时我们应清楚优化器根据何种原则来删除索引,这有助于写出高性能的SQL语句。

二、SQL语句编写注意问题
下面就某些SQL语句的where子句编写中需要注意的问题作详细介绍。在这些where子句中,即使某些列存在索引,但是由于编写了劣质的SQL,系统在运行该SQL语句时也不能使用该索引,而同样使用全表扫描,这就造成了响应速度的极大降低。

1. IS NULL 与 IS NOT NULL
不能用null作索引,任何包含null值的列都将不会被包含在索引中。即使索引有多列这样的情况下,只要这些列中有一列含有null,该列就会从索引中排除。也就是说如果某列存在空值,即使对该列建索引也不会提高性能。

任何在where子句中使用is null或is not null的语句优化器是不允许使用索引的。

2. 联接列

对于有联接的列,即使最后的联接值为一个静态值,优化器是不会使用索引的。我们一起来看一个例子,假定有一个职工表(employee),对于一个职工的姓和名分成两列存放(FIRST_NAME和LAST_NAME),现在要查询一个叫比尔.克林顿(Bill Cliton)的职工。

下面是一个采用联接查询的SQL语句,

select * from employss
where
first_name||”||last_name =’Beill Cliton’

上面这条语句完全可以查询出是否有Bill Cliton这个员工,但是这里需要注意,系统优化器对基于last_name创建的索引没有使用。

当采用下面这种SQL语句的编写,Oracle系统就可以采用基于last_name创建的索引。

Select * from employee
where
first_name =’Beill’ and last_name =’Cliton’

遇到下面这种情况又如何处理呢?如果一个变量(name)中存放着Bill Cliton这个员工的姓名,对于这种情况我们又如何避免全程遍历,使用索引呢?可以使用一个函数,将变量name中的姓和名分开就可以了,但是有一点需要注意,这个函数是不能作用在索引列上。下面是SQL查询脚本:

select * from employee
where
first_name = SUBSTR(‘&&name’,1,INSTR(‘&&name’,’ ‘)-1)
and
last_name = SUBSTR(‘&&name’,INSTR(‘&&name’,’ ‘)+1)

3. 带通配符(%)的like语句

同样以上面的例子来看这种情况。目前的需求是这样的,要求在职工表中查询名字中包含cliton的人。可以采用如下的查询SQL语句:

select * from employee where last_name like ‘%cliton%’

这里由于通配符(%)在搜寻词首出现,所以Oracle系统不使用last_name的索引。在很多情况下可能无法避免这种情况,但是一定要心中有底,通配符如此使用会降低查询速度。然而当通配符出现在字符串其他位置时,优化器就能利用索引。在下面的查询中索引得到了使用:

select * from employee where last_name like ‘c%’

4. Order by语句

ORDER BY语句决定了Oracle如何将返回的查询结果排序。Order by语句对要排序的列没有什么特别的限制,也可以将函数加入列中(象联接或者附加等)。任何在Order by语句的非索引项或者有计算表达式都将降低查询速度。

仔细检查order by语句以找出非索引项或者表达式,它们会降低性能。解决这个问题的办法就是重写order by语句以使用索引,也可以为所使用的列建立另外一个索引,同时应绝对避免在order by子句中使用表达式。

5. NOT

我们在查询时经常在where子句使用一些逻辑表达式,如大于、小于、等于以及不等于等等,也可以使用and(与)、or(或)以及not(非)。NOT可用来对任何逻辑运算符号取反。下面是一个NOT子句的例子:

… where not (status =’VALID’)

如果要使用NOT,则应在取反的短语前面加上括号,并在短语前面加上NOT运算符。NOT运算符包含在另外一个逻辑运算符中,这就是不等于(<&gt$$)运算符。换句话说,即使不在查询where子句中显式地加入NOT词,NOT仍在运算符中,见下例:

… where status <&gt$$’INVALID’

再看下面这个例子:

select * from employee where salary<&gt$$3000;

对这个查询,可以改写为不使用NOT:

select * from employee where salary<3000 or salary&gt$$3000;

虽然这两种查询的结果一样,但是第二种查询方案会比第一种查询方案更快些。第二种查询允许Oracle对salary列使用索引,而第一种查询则不能使用索引。

6. IN和EXISTS

有时候会将一列和一系列值相比较。最简单的办法就是在where子句中使用子查询。在where子句中可以使用两种格式的子查询。

第一种格式是使用IN操作符:

… where column in(select * from … where …);

第二种格式是使用EXIST操作符:

… where exists (select ‘X’ from …where …);

我相信绝大多数人会使用第一种格式,因为它比较容易编写,而实际上第二种格式要远比第一种格式的效率高。在Oracle中可以几乎将所有的IN操作符子查询改写为使用EXISTS的子查询。

第二种格式中,子查询以‘select ‘X’开始。运用EXISTS子句不管子查询从表中抽取什么数据它只查看where子句。这样优化器就不必遍历整个表而仅根据索引就可完成工作(这里假定在where语句中使用的列存在索引)。相对于IN子句来说,EXISTS使用相连子查询,构造起来要比IN子查询困难一些。

通过使用EXIST,Oracle系统会首先检查主查询,然后运行子查询直到它找到第一个匹配项,这就节省了时间。Oracle系统在执行IN子查询时,首先执行子查询,并将获得的结果列表存放在在一个加了索引的临时表中。在执行子查询之前,系统先将主查询挂起,待子查询执行完毕,存放在临时表中以后再执行主查询。这也就是使用EXISTS比使用IN通常查询速度快的原因。

同时应尽可能使用NOT EXISTS来代替NOT IN,尽管二者都使用了NOT(不能使用索引而降低速度),NOT EXISTS要比NOT IN查询效率更高。

MySQL-Cluster集群研究


MySQL-Cluster集群研究


from: discuz wiki

一、介绍

这篇文档旨在介绍如何安装配置基于2台服务器的MySQL集群。并且实现任意一台服务器出现问题或宕机时MySQL依然能够继续运行。

注意!
虽然这是基于2台服务器的MySQL集群,但也必须有额外的第三台服务器作为管理节点,但这台服务器可以在集群启动完成后关闭。同时需要注意的是并不推荐在集群启动完成后关闭作为管理节点的服务器。尽管理论上可以建立基于只有2台服务器的MySQL集群,但是这样的架构,一旦一台服务器宕机之后集群就无法继续正常工作了,这样也就失去了集群的意义了。出于这个原因,就需要有第三台服务器作为管理节点运行。

另外,可能很多朋友都没有3台服务器的实际环境,可以考虑在VMWare或其他虚拟机中进行实验。

下面假设这3台服务的情况:







Server1: mysql1.vmtest.net 192.168.0.1
Server2: mysql2.vmtest.net 192.168.0.2
Server3: mysql3.vmtest.net 192.168.0.3


Servers1和Server2作为实际配置MySQL集群的服务器。对于作为管理节点的Server3则要求较低,只需对Server3的系统进行很小的调整并且无需安装MySQL,Server3可以使用一台配置较低的计算机并且可以在Server3同时运行其他服务。


二、在Server1和Server2上安装MySQL

http://www.mysql.com上下载mysql-max-4.1.9-pc-linux-gnu-i686.tar.gz

注意:必须是max版本的MySQL,Standard版本不支持集群部署!

以下步骤需要在Server1和Server2上各做一次





# mv mysql-max-4.1.9-pc-linux-gnu-i686.tar.gz /usr/local/
# cd /usr/local/
# groupadd mysql
# useradd -g mysql mysql
# tar -zxvf mysql-max-4.1.9-pc-linux-gnu-i686.tar.gz
# rm -f mysql-max-4.1.9-pc-linux-gnu-i686.tar.gz
# mv mysql-max-4.1.9-pc-linux-gnu-i686 mysql
# cd mysql
# scripts/mysql_install_db –user=mysql
# chown -R root  .
# chown -R mysql data
# chgrp -R mysql .
# cp support-files/mysql.server /etc/rc.d/init.d/mysqld
# chmod +x /etc/rc.d/init.d/mysqld
# chkconfig –add mysqld


此时不要启动MySQL!


三、安装并配置管理节点服务器(Server3)

作为管理节点服务器,Server3需要ndb_mgm和ndb_mgmd两个文件:

http://www.mysql.com上下载mysql-max-4.1.9-pc-linux-gnu-i686.tar.gz






# mkdir /usr/src/mysql-mgm
# cd /usr/src/mysql-mgm
# tar -zxvf mysql-max-4.1.9-pc-linux-gnu-i686.tar.gz
# rm mysql-max-4.1.9-pc-linux-gnu-i686.tar.gz
# cd mysql-max-4.1.9-pc-linux-gnu-i686
# mv bin/ndb_mgm .
# mv bin/ndb_mgmd .
# chmod +x ndb_mg*
# mv ndb_mg* /usr/bin/
# cd
# rm -rf /usr/src/mysql-mgm


现在开始为这台管理节点服务器建立配置文件:






# mkdir /var/lib/mysql-cluster
# cd /var/lib/mysql-cluster
# vi config.ini




在config.ini中添加如下内容:






[NDBD DEFAULT]
NoOfReplicas=2
[MYSQLD DEFAULT]
[NDB_MGMD DEFAULT]
[TCP DEFAULT]
# Managment Server
[NDB_MGMD]
HostName=192.168.0.3 #管理节点服务器Server3的IP地址
# Storage Engines
[NDBD]
HostName=192.168.0.1 #MySQL集群Server1的IP地址
DataDir= /var/lib/mysql-cluster
[NDBD]
HostName=192.168.0.2 #MySQL集群Server2的IP地址
DataDir=/var/lib/mysql-cluster
# 以下2个[MYSQLD]可以填写Server1和Server2的主机名。
# 但为了能够更快的更换集群中的服务器,推荐留空,否则更换服务器后必须对这个配置进行更改。
[MYSQLD]
[MYSQLD]



保存退出后,启动管理节点服务器Server3:






# ndb_mgmd


启动管理节点后应该注意,这只是管理节点服务,并不是管理终端。因而你看不到任何关于启动后的输出信息。


四、配置集群服务器并启动MySQL

在Server1和Server2中都需要进行如下改动:






# vi /etc/my.cnf








[mysqld]
ndbcluster
ndb-connectstring=192.168.0.3 #Server3的IP地址
[mysql_cluster]
ndb-connectstring=192.168.0.3 #Server3的IP地址




保存退出后,建立数据目录并启动MySQL:






# mkdir /var/lib/mysql-cluster
# cd /var/lib/mysql-cluster
# /usr/local/mysql/bin/ndbd –initial
# /etc/rc.d/init.d/mysqld start



可以把/usr/local/mysql/bin/ndbd加到/etc/rc.local中实现开机启动。

注意:只有在第一次启动ndbd时或者对Server3的config.ini进行改动后才需要使用–initial参数!


五、检查工作状态

回到管理节点服务器Server3上,并启动管理终端:






# /usr/bin/ndb_mgm



键入show命令查看当前工作状态:(下面是一个状态输出示例)







[root@mysql3 root]# /usr/bin/ndb_mgm
— NDB Cluster — Management Client —
ndb_mgm> show
Connected to Management Server at: localhost:1186
Cluster Configuration
———————
[ndbd(NDB)]     2 node(s)
id=2    @192.168.0.1  (Version: 4.1.9, Nodegroup: 0, Master)
id=3    @192.168.0.2  (Version: 4.1.9, Nodegroup: 0)
[ndb_mgmd(MGM)] 1 node(s)
id=1    @192.168.0.3  (Version: 4.1.9)
[mysqld(API)]   2 node(s)
id=4   (Version: 4.1.9)
id=5   (Version: 4.1.9)
ndb_mgm>




如果上面没有问题,现在开始测试MySQL:

注意,这篇文档对于MySQL并没有设置root密码,推荐你自己设置Server1和Server2的MySQL root密码。

在Server1中:






# /usr/local/mysql/bin/mysql -u root -p
> use test;
> CREATE TABLE ctest (i INT) ENGINE=NDBCLUSTER;
> INSERT INTO ctest () VALUES (1);
> SELECT * FROM ctest;



应该可以看到1 row returned信息(返回数值1)。

如果上述正常,则换到Server2上重复上面的测试,观察效果。如果成功,则在Server2中执行INSERT再换回到Server1观察是否工作正常。

如果都没有问题,那么恭喜成功!


六、破坏性测试

将Server1或Server2的网线拔掉,观察另外一台集群服务器工作是否正常(可以使用SELECT查询测试)。测试完毕后,重新插入网线即可。

如果你接触不到物理服务器,也就是说不能拔掉网线,那也可以这样测试:在Server1或Server2上:






# ps aux | grep ndbd



将会看到所有ndbd进程信息:






root      5578  0.0  0.3  6220 1964 ?        S    03:14   0:00 ndbd
root      5579  0.0 20.4 492072 102828 ?     R    03:14   0:04 ndbd
root     23532  0.0  0.1  3680  684 pts/1    S    07:59   0:00 grep ndbd




然后杀掉一个ndbd进程以达到破坏MySQL集群服务器的目的:






# kill -9 5578 5579



之后在另一台集群服务器上使用SELECT查询测试。并且在管理节点服务器的管理终端中执行show命令会看到被破坏的那台服务器的状态。

测试完成后,只需要重新启动被破坏服务器的ndbd进程即可:







# ndbd



注意!前面说过了,此时是不用加–inital参数的!



至此,MySQL集群就配置完成了!

 

文章来源:http://www.mysqlpub.com/viewthread.php?tid=194&extra=page%3D1

Your First Groovy



Your First Groovy



//hello.groovy
println “hello, world”

for (arg in this.args ) {

println “Argument:” + arg;

}

// this is a comment

/* a block comment, commenting out an alternative to above:

this.args.each{ arg -> println “hello, ${arg}”}

*/

To run it from command line



groovy hello.groovy MyName yourName HisName


Overview


Groovy classes compile down to Java bytecode and so there’s a 1-1 mapping between a Groovy class and a Java class.

Indeed each Groovy class can be used inside normal Java code – since it is a Java class too.


Probably the easiest way to get groovy is to try working with collections. In Groovy List (java.util.List) and Map (java.util.Map) are both first class objects in the syntax. So to create a List of objects you can do the following…



def list = [1, 2, ‘hello’, new java.util.Date()]

assert list.size() == 4

assert list.get(2) == ‘hello’

assert list[2] == ‘hello’

Notice that everything is an object (or that auto-boxing takes place when working with numbers). To create maps…



def map = [‘name’:’James’, ‘location’:’London’]

assert map.size() == 2

assert map.get(‘name’) == ‘James’

assert map[‘name’] == ‘James’

Iterating over collections is easy…



def list = [1, 2, 3]

for (i in list) { println i }

Once you have some collections you can then use some of the new collection helper methods or try working with closures…



Working with closures


Closures are similar to Java’s inner classes, except they are a single method which is invokable, with arbitrary parameters. A closure can have as many parameters as you wish…



def closure = { param -> println(“hello ${param}”) }

closure.call(“world!”)

closure = { greeting, name -> println(greeting + name) }

closure.call(“hello “, “world!”)


If no parameter(s) is(are) specified before -> symbol then a default named parameter, called ‘it’ can be used. e.g.



def closure = { println “hello “ + it }

closure.call(“world!”)

Using closures allows us to process collections (arrays, maps, strings, files, SQL connections and so forth) in a clean way. e.g



[1, 2, 3].each ({ item -> print “${item}-“ })

[“k1”:“v1”, “k2”:“v2”].each {key, value -> println key + “=” + value}

Note: If a given closure is the last parameter of a method, its definition can reside outside of the parentheses. Thus the following code is valid:



def fun(int i, Closure c) {

c.call(i)

}

// put Closure out of ()

[1, 2, 3].each() { item -> print “${item}-“ } // 1-2-3-

fun(123) { i -> println i } // 123

// omit ()



[1, 2, 3].each ({ item -> print “${item}-“ }) // 1-2-3-



// omit enclosing ()
[1, 2, 3].each { item -> print “${item}-“ } // 1-2-3-

// normal
[1, 2, 3].each(({ item -> print “${item}-“ })) // 1-2-3-

// using the fun function to do the same thing
[1,2,3].each {fun(it,{item -> print “${item}-“})} // 1-2-3-

def closure = { i -> println i}

//[1, 2, 3].each() closure // error. closure has been previously defined

Here are a number of helper methods available on collections & strings…



each


iterate via a closure



[1, 2, 3].each { item -> print “${item}-“ }


collect


collect the return value of calling a closure on each item in a collection



def value = [1, 2, 3].collect { it * 2 }

assert value == [2, 4, 6]


find


finds first item matching closure predicate



def value = [1, 2, 3].find { it > 1 }

assert value == 2


findAll


finds all items matching closure predicate



def value = [1, 2, 3].findAll { it > 1 }

assert value == [2, 3]


inject


allows you to pass a value into the first iteration and then pass the result of that iteration into the next iteration and so on. This is ideal for counting and other forms of processing



def value = [1, 2, 3].inject(‘counting: ‘) { str, item -> str + item }

assert value == “counting: 123”

value = [1, 2, 3].inject(0) { count, item -> count + item }

assert value == 6


In addition there’s 2 new methods for doing boolean logic on some collection…



every


returns true if all items match the closure predicate



def value = [1, 2, 3].every { it < 5 }

assert value

value = [1, 2, 3].every { item -> item < 3 }

assert ! value



any


returns true if any item match the closure predicate



def value = [1, 2, 3].any { it > 2 }

assert value

value = [1, 2, 3].any { item -> item > 3 }

assert value == false


Other helper methods include:



max / min


returns the max/min values of the collection – for Comparable objects



value = [9, 4, 2, 10, 5].max()

assert value == 10

value = [9, 4, 2, 10, 5].min()

assert value == 2

value = [‘x’, ‘y’, ‘a’, ‘z’].min()

assert value == ‘a’


join


concatenates the values of the collection together with a string value



def value = [1, 2, 3].join(‘-‘)

assert value == ‘1-2-3’

install Groovy in RedHat as4

官方网是这样写的:
1,first, Download a binary distribution of Groovy and unpack it into some file on your local file system
2,set your GROOVY_HOME environment variable to the directory you unpacked the distribution
3,add GROOVY_HOME/bin to your PATH environment variable
4,set your JAVA_HOME environment variable to point to your JDK. On OS X this is /Library/Java/Home, on other unixes its often /usr/java etc. If you’ve already installed tools like Ant or Maven you’ve probably already done this step.

但会出现错误:
# groovysh
java.lang.NoClassDefFoundError: org/objectweb/asm/ClassVisitor
        at groovy.lang.GroovySystem.<clinit>(GroovySystem.java:27)
        at org.codehaus.groovy.runtime.Invoker.<init>(Invoker.java:38)
        at org.codehaus.groovy.runtime.InvokerHelper.<clinit>(InvokerHelper.java:44)
        at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.invokeNewN(ScriptBytecodeAdapter.java:225)
        at org.codehaus.groovy.tools.shell.Main.<clinit>(Main.groovy:34)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at org.codehaus.groovy.tools.GroovyStarter.rootLoader(GroovyStarter.java:101)
        at org.codehaus.groovy.tools.GroovyStarter.main(GroovyStarter.java:130)


解决办法:
#vi /etc/profile

加入GROOVY_HOME
export GROOVY_HOME=”/home1/software/groovy-1.5.0/”

修改CLASSPATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:”/home1/lib/”:$GROOVY_HOME/lib/ant-1.7.0.jar:$GROOVY_HOME/lib/asm-2.2.jar:$GROOVY_HOME/lib/bsf-2.4.0.jar:$GROOVY_HOME/lib/jline-0.9.93.jar:$GROOVY_HOME/lib/mx4j-3.0.2.jar:$GROOVY_HOME/lib/ant-junit-1.7.0.jar:$GROOVY_HOME/lib/asm-analysis-2.2.jar:$GROOVY_HOME/lib/commons-cli-1.0.jar:$GROOVY_HOME/lib/jsp-api-2.0.jar:$GROOVY_HOME/lib/servlet-api-2.4.jar:$GROOVY_HOME/lib/ant-launcher-1.7.0.jar:$GROOVY_HOME/lib/asm-tree-2.2.jar:$GROOVY_HOME/lib/commons-logging-1.1.jar:$GROOVY_HOME/lib/junit-3.8.2.jar:$GROOVY_HOME/lib/xpp3_min-1.1.3.4.O.jar:$GROOVY_HOME/lib/antlr-2.7.6.jar:$GROOVY_HOME/lib/asm-util-2.2.jar:$GROOVY_HOME/lib/groovy-1.5.0.jar:$GROOVY_HOME/lib/mockobjects-core-0.09.jar:$GROOVY_HOME/lib/xstream-1.2.2.jar

mysqlbinlog 資料庫處理二進制日誌檔案的實用工具

當然,系統剛弄好是沒有開啟 mysqlbinlog 的功能,至少在 CentOS4.4 上面我還要去開啟,不過 ubuntu 系統預設就已經開啟了,不過沒關係,只要利用下面方法就可以達到了


修改 my.cnf [ CentOS: /etc/my.cnf Ubuntu: /etc/mysql/my.cnf ],加入下面語法



# Replication Master Server (default)
# binary logging is required for replication
log-BIN=mysql-BIN


不過話說當你開啟這個功能之後,你會發現在 /var/lib/mysql/ 底下多出很多檔案



-rw-rw—-   1 mysql mysql  33164904  117 15:44 mysql-bin.000001
-rw-rw—-   1 mysql mysql      4007  117 15:50 mysql-bin.000002
-rw-rw—-   1 mysql mysql  70288989  129 22:38 mysql-bin.000003
-rw-rw—-   1 mysql mysql     16665  129 22:41 mysql-bin.000004
-rw-rw—-   1 mysql mysql      4792  129 22:42 mysql-bin.000005
-rw-rw—-   1 mysql mysql  56274069  210 06:25 mysql-bin.000006
-rw-rw—-   1 mysql mysql 893963240  329 09:21 mysql-bin.000007
-rw-rw—-   1 mysql mysql 666605284  329 09:39 mysql-bin.000008
-rw-rw—-   1 mysql mysql    151946  329 10:02 mysql-bin.000009
-rw-rw—-   1 mysql mysql   3450785  329 22:38 mysql-bin.000010

上面就是產生 mysqlbinlog 檔案,當然如果你要觀看那一個檔案下指令吧



shell> mysqlbinlog binlog.0000003


裏面的語法包跨 每個語句花費的時間、客戶發出的線程ID、發出線程時的時間戳,也可以遠端觀看


當讀取遠程二進制日誌時,可以通過連接參數選項來指示如何連接伺服器,但它們經常被忽略掉,除非您還指定了–read-from-remote-server選項。這些選項是–host、–password、–port、–protocol、–socket和–user。


底下來說明一下用法~


1. 指定恢復時間語法


假如你今天早上9點不小心砍掉哪個資料庫的資料表,你可以利用下面語法來恢復



mysqlbinlog –stop-date=“2007-03-29 8:59:59”  /var/lib/mysql/bin.000001 | mysql -u root -p

如果你想恢復後面9點以後sql語法 可以使用



mysqlbinlog –start-date=“2007-03-29 9:00:00”  /var/lib/mysql/bin.000001 | mysql -u root -p

或者是 你想恢復 9點到10點之間的sql語法,則下面語法是您想要的



mysqlbinlog –start-date=“2007-03-29 9:00:00”  –stop-date=“2007-03-29 10:00:00” /var/lib/mysql/bin.000001 | mysql -u root -p

其實你也可以不要執行,先把sql語法輸出到 /tmp/restore.sql



mysqlbinlog –start-date=“2007-03-29 9:00:00”  –stop-date=“2007-03-29 10:00:00” /var/lib/mysql/bin.000001 &gt; /tmp/restore.sql

當然 你也可以指定你要輸出的 database,免的檔案很大



database=db_name,-d db_name
host=host_name,-h host_name

Timer Server

import java.io.InterruptedIOException;
import javax.microedition.io.Connector;
import javax.microedition.io.Datagram;
import javax.microedition.io.DatagramConnection;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.StringItem;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class TimeMIDlet extends MIDlet
                    implements CommandListener, Runnable {

    private Display display;
    private Form addressForm;
    private Form connectForm;
    private Form displayForm;
    private Command backCommand;
    private Command exitCommand;
    private Command okCommand;
    private StringItem messageLabel;
    private TextField serverName;

    protected void startApp() throws MIDletStateChangeException {
        if (display == null) {
            initialize();
            display.setCurrent(addressForm);
        }
    }

    protected void pauseApp() {
    }

    protected void destroyApp(boolean unconditional)
                        throws MIDletStateChangeException {
    }

    public void commandAction(Command cmd, Displayable d) {
        if (cmd == okCommand) {
            Thread t = new Thread(this);
            t.start();
        else if (cmd == backCommand) {
            display.setCurrent(addressForm);
        else if (cmd == exitCommand) {
            try {
                destroyApp(true);
            catch (MIDletStateChangeException ex) {
            }
            notifyDestroyed();
        }
    }

    public void run() {
        DatagramConnection conn = null;
        display.setCurrent(connectForm);

        try {
            // Build the name string for the Connector open method
            String server = serverName.getString();
            String name = “datagram://” + server + “:” 13;
            conn = (DatagramConnection)Connector.open(name,
                                    Connector.READ_WRITE, false);

            // Build and send an empty datagram
            Datagram dg = conn.newDatagram(10);
            dg.setData(“Hello”.getBytes()05);
            conn.send(dg);

            // Receive the reply
            Datagram rdg = conn.newDatagram(512);
            conn.receive(rdg);
            messageLabel.setText(new String(rdg.getData()0, rdg.getLength()));
            display.setCurrent(displayForm);

        catch (InterruptedIOException iex) {
            display.callSerially(new Runnable() {
                public void run() {
                    Alert alert = new Alert(“No Reply”,
                        “No reply was received.\n” +
                        “Please check the server address and try again.”, null,
                        AlertType.ERROR);
                    alert.setTimeout(Alert.FOREVER);
                    display.setCurrent(alert, addressForm);
                }
            });
            return;
        catch (Exception ex) {
            display.callSerially(new Runnable() {
                public void run() {
                    Alert alert = new Alert(“Invalid Address”,
                        “The supplied address is invalid\n” +
                        “Please correct it and try again.”, null,
                        AlertType.ERROR);
                    alert.setTimeout(Alert.FOREVER);
                    display.setCurrent(alert, addressForm);
                }
            });
            return;
        catch (Error err) {
            System.out.println(err);
            err.printStackTrace();
        }
    }

    private void initialize() {
        display = Display.getDisplay(this);

        // Commands
        exitCommand = new Command(“Exit”, Command.EXIT, 0);
        okCommand = new Command(“OK”, Command.OK, 0);
        backCommand = new Command(“Back”, Command.BACK, 0);

        // The address form
        addressForm = new Form(“Network Time”);
        serverName = new TextField(“Time Server name:”“tock.usno.navy.mil”,
                                            256, TextField.ANY);
        addressForm.append(serverName);
        addressForm.addCommand(okCommand);
        addressForm.addCommand(exitCommand);
        addressForm.setCommandListener(this);

        // The connect form
        connectForm = new Form(“Sending”);
        messageLabel = new StringItem(null,
                    “Sending the datagram…\nPlease wait.”);
        connectForm.append(messageLabel);
        connectForm.addCommand(backCommand);
        connectForm.setCommandListener(this);

        // The display form
        displayForm = new Form(“Server Reply”);
        messageLabel = new StringItem(null, null);
        displayForm.append(messageLabel);
        displayForm.addCommand(backCommand);
        displayForm.setCommandListener(this);
    }
}

J2ME Datagram Receiver

import java.io.IOException;
import javax.microedition.io.Connector;
import javax.microedition.io.Datagram;
import javax.microedition.io.DatagramConnection;

public class DatagramReceiver {
    public static void main(String[] args) {
        if (args.length != 1) {
            System.out.println(“Usage: DatagramReceiver port”);
            System.exit(1);
        }
        
        try {
            DatagramConnection receiver = 
                    (DatagramConnection)Connector.open(“datagram://:” + args[0]);
            byte[] buffer = new byte[256];
            Datagram dgram = receiver.newDatagram(buffer, buffer.length);
            for ($$) {
                dgram.setLength(buffer.length);
                receiver.receive(dgram);
                int length = dgram.getLength();
                System.out.println(“Datagram received. Length is ” + length);

                // Show the content of the datagram.
                for (int i = 0; i < length; i++) {
                    System.out.print(buffer[i” “);
                }
                System.out.println();
                
                // Send it back…
                receiver.send(dgram);
            }
        catch (IOException ex) {
            System.out.println(“IOException: ” + ex);
        }
    }
}


J2ME DatagramSender

import java.io.IOException;
import javax.microedition.io.Connector;
import javax.microedition.io.Datagram;
import javax.microedition.io.DatagramConnection;

public class DatagramSender {
    public static void main(String[] args) {
        if (args.length != 2) {
            System.out.println(“Usage: DatagramSender port length”);
            System.exit(1);
        }
        
        try {
            DatagramConnection sender = 
                    (DatagramConnection)Connector.open(“datagram://localhost:” + args[0]);
            int length = Integer.parseInt(args[1]);
            byte[] buffer = new byte[length];
            for (int i = 0; i < length; i++) {
                buffer[i(byte)(‘0’ (i % 10));
            }
            Datagram dgram = sender.newDatagram(buffer, buffer.length);
            sender.send(dgram);
            
            // Wait for the packet to be returned
            for (int i = 0; i < length; i++) {
                buffer[i(byte)0;
            }
            sender.receive(dgram);
            length = dgram.getLength();
            System.out.println(“Received return packet, length is ” + length);
            
            // Show the content of the datagram.
            for (int i = 0; i < length; i++) {
                System.out.print(buffer[i” “);
            }
            System.out.println();
        catch (IOException ex) {
            System.out.println(“IOException: ” + ex);
        }
    }
}


Demonstrates the functionality of DatagramConnection framework.

/*** Chapter 5 Sample Code for Datagram functionality ***/

import 
javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.io.*;
import java.util.*;

public class DatagramTest extends MIDlet {

  // Port 9001 is used for datagram communication
    static final int receiveport  = 9001;
  Receive receiveThread = new Receive();

    public DatagramTest() {
  }

    public void startApp() {
        // Start the listening thread
        receiveThread.start();
        // Send message Hello World!
        sendMessage(“Hello World!”);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional)  {
    }

  // This function sends a datagram message on port 9001.
    void sendMessage(String msg)  {
    String destAddr = “datagram://localhost:” + receiveport;
        DatagramConnection dc = null;
    Datagram dgram;
    byte[] bMsg = msg.getBytes();

    try {
           dc = (DatagramConnection)Connector.open(destAddr);
      // Create a datagram socket and send
            dgram= dc.newDatagram(bMsg,bMsg.length,destAddr);
            dc.send(dgram);
      System.out.println(“Sending Packet:” +  msg);
            dc.close();
        }
        catch (Exception e)  {
            System.out.println(“Exception Connecting: ” + e.getMessage());
    }
    finally {
            if (dc != null) {
                try {
                    dc.close();
                }
                catch (Exception e) {
                   System.out.println(“Exception Closing: ” + e.getMessage());
                }
            }
        }
    }

  // This function is a listener. It waits to receive datagram packets on 9001 port
    class Receive extends Thread  {
        public void run() {
        doReceive();
        }

        void doReceive() {
            DatagramConnection dc = null;
            Datagram dgram;
      try {
        // Open Server side datagram connection
                dc = (DatagramConnection)Connector.open(“datagram://:”+receiveport);
          String receivedMsg;
          while (true) {
                    dgram = dc.newDatagram(dc.getMaximumLength());
                try {
             dc.receive(dgram);
          catch (Exception e) {
            System.out.println(“Exception in receiving message:” + e.getMessage());
          }
                    receivedMsg = new String(dgram.getData()0,dgram.getLength());
                    System.out.println(“Received Message: ” + receivedMsg);
                    try {
                       Thread.sleep(500);
                    }
                    catch (Exception e) {
                      System.out.println(“Exception doReceive(): ” + e.getMessage());
                    }
                }

            }
          catch (Exception e) {
          System.out.println(“Exception doReceive(): ” + e.getMessage());
       }
       finally {
          if (dc != null) {
          try {
                       dc.close();
                   }
                   catch (Exception e) {
                      System.out.println(“Exception Closing: ” + e.getMessage());
                   }
               }
          }

        }
     }
 }


j2me:Socket connection

/*
J2ME: The Complete Reference


James Keogh

Publisher: McGraw-Hill

ISBN 0072227109

*/
// jad file (Please verify the jar size first)
/*
MIDlet-Name: socketconnection
MIDlet-Version: 1.0
MIDlet-Vendor: MyCompany
MIDlet-Jar-URL: socketconnection.jar
MIDlet-1: socketconnection, , socketconnection
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100

*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.io.*;
import javax.microedition.io.*;
public class socketconnection extends MIDlet implements CommandListener {
  private Command exit, start;
  private Display display;
  private Form form;
  public socketconnection () 
  {
    display = Display.getDisplay(this);
    exit = new Command(“Exit”, Command.EXIT, 1);
    start = new Command(“Start”, Command.EXIT, 1);
    form new Form(“Read Write Socket”);
    form.addCommand(exit);
    form.addCommand(start);
    form.setCommandListener(this);
  }
  public void startApp() throws MIDletStateChangeException 
  {
    display.setCurrent(form);
  }
  public void pauseApp() 
  {
  }
  public void destroyApp(boolean unconditional
  {
  }
  public void commandAction(Command command, Displayable displayable
  {
    if (command == exit
    {
      destroyApp(false);
      notifyDestroyed();
    }
    else if (command == start
    {
      try 
      {
       StreamConnection connection = (StreamConnectionConnector.open(“socket://www.myserver.com:80”);
       PrintStream output = 
         new PrintStream(connection.openOutputStream() );
       output.println“GET /my.html HTTP/0.9\n\n” );
       output.flush();
       InputStream in = connection.openInputStream();
       int ch;
       while( ( ch = in.read() ) != –)
      {
         System.out.print( (charch );
       }
       in.close();
       output.close();
       connection.close();
     }
      catchConnectionNotFoundException error )
       {
         Alert alert = new Alert(
            “Error”“Cannot access socket.”, null, null);
         alert.setTimeout(Alert.FOREVER);
         alert.setType(AlertType.ERROR);
         display.setCurrent(alert);      
        }
        catchIOException error )
        {
         Alert alert = new Alert(“Error”, error.toString(), null, null);
         alert.setTimeout(Alert.FOREVER);
         alert.setType(AlertType.ERROR);
         display.setCurrent(alert);
        }
    }
  }
}