Ms SQL Server 2005 seems to go one step further by announcing future deprecation for ntext, text and image types.
From Sql Server 2005 notes:
“ntext, text, and image data types will be removed in a future version of Microsoft SQL Server. Avoid using these data types in new development work, and plan to modify applications that currently use them. Use nvarchar(max), varchar(max), and varbinary(max) instead.”
When working with Hibernate it seems there is no dialect to handle Unicode integration properly. You have to get down and write a custom dialect that maps to the new data types.
/**
* Unicode support in SQL Server
*
* @author icocan
*/
public class UnicodeSQLServerDialect extends SQLServerDialect {
public UnicodeSQLServerDialect() {
super();
// Use Unicode Characters
registerColumnType(Types.VARCHAR, 255, "nvarchar($l)");
registerColumnType(Types.CHAR, "nchar(1)");
registerColumnType(Types.CLOB, "nvarchar(max)");
// Microsoft SQL Server 2000 supports bigint and bit
registerColumnType(Types.BIGINT, "bigint");
registerColumnType(Types.BIT, "bit");
}
}
You have to write your own SQLServerDialect class, it looks something like this:
publicclassSQLServerNativeDialectextendsSQLServerDialect{
publicSQLServerNativeDialect(){
super();
registerColumnType(Types.VARCHAR,"nvarchar($l)");
registerColumnType(Types.CLOB,"nvarchar(max)");
}
publicString getTypeName(int code,int length,int precision,int scale)throwsHibernateException{
if(code !=2005){
returnsuper.getTypeName(code, length, precision, scale);
}else{
return"ntext";
}
}
}
This class maps Hibernate's types to SQL types, so the class will map the nvarchar(max) SQL Data Type to Hibernate's CLOB data type.
The getTypeName method is used to return "ntext" when Hibernate asks about the data type with code 2005 (which looks like it's the nvarchar(max) data type).
Finally, you need to change your hibernate persistence dialect to this new SQLServerDialect class, which allows hibernate to translate data types into SQL data types.
]]>
Introduction
MySQLdb is an thread-compatible interface to the popular MySQL database server that provides the Python database API.
Installation
The README file has complete installation instructions.
_mysql
If you want to write applications which are portable across databases, use MySQLdb, and avoid using this module directly. _mysql provides an interface which mostly implements the MySQL C API. For more information, see the MySQL documentation. The documentation for this module is intentionally weak because you probably should use the higher-level MySQLdb module. If you really need it, use the standard MySQL docs and transliterate as necessary.
MySQL C API translation
The MySQL C API has been wrapped in an object-oriented way. The only MySQL data structures which are implemented are the MYSQL (database connection handle) and MYSQL_RES (result handle) types. In general, any function which takes MYSQL *mysql as an argument is now a method of the connection object, and any function which takes MYSQL_RES *result as an argument is a method of the result object. Functions requiring none of the MySQL data structures are implemented as functions in the module. Functions requiring one of the other MySQL data structures are generally not implemented. Deprecated functions are not implemented. In all cases, the mysql_ prefix is dropped from the name. Most of the conn methods listed are also available as MySQLdb Connection object methods. Their use is non-portable.
MySQL C API function mapping
| C API | _mysql |
|---|---|
| mysql_affected_rows() | conn.affected_rows() |
| mysql_autocommit() | conn.autocommit() |
| mysql_character_set_name() | conn.character_set_name() |
| mysql_close() | conn.close() |
| mysql_commit() | conn.commit() |
| mysql_connect() | _mysql.connect() |
| mysql_data_seek() | result.data_seek() |
| mysql_debug() | _mysql.debug() |
| mysql_dump_debug_info | conn.dump_debug_info() |
| mysql_escape_string() | _mysql.escape_string() |
| mysql_fetch_row() | result.fetch_row() |
| mysql_get_character_set_info() | conn.get_character_set_info() |
| mysql_get_client_info() | _mysql.get_client_info() |
| mysql_get_host_info() | conn.get_host_info() |
| mysql_get_proto_info() | conn.get_proto_info() |
| mysql_get_server_info() | conn.get_server_info() |
| mysql_info() | conn.info() |
| mysql_insert_id() | conn.insert_id() |
| mysql_num_fields() | result.num_fields() |
| mysql_num_rows() | result.num_rows() |
| mysql_options() | various options to _mysql.connect() |
| mysql_ping() | conn.ping() |
| mysql_query() | conn.query() |
| mysql_real_connect() | _mysql.connect() |
| mysql_real_query() | conn.query() |
| mysql_real_escape_string() | conn.escape_string() |
| mysql_rollback() | conn.rollback() |
| mysql_row_seek() | result.row_seek() |
| mysql_row_tell() | result.row_tell() |
| mysql_select_db() | conn.select_db() |
| mysql_set_character_set() | conn.set_character_set() |
| mysql_ssl_set() | ssl option to _mysql.connect() |
| mysql_stat() | conn.stat() |
| mysql_store_result() | conn.store_result() |
| mysql_thread_id() | conn.thread_id() |
| mysql_thread_safe_client() | conn.thread_safe_client() |
| mysql_use_result() | conn.use_result() |
| mysql_warning_count() | conn.warning_count() |
| CLIENT_* | MySQLdb.constants.CLIENT.* |
| CR_* | MySQLdb.constants.CR.* |
| ER_* | MySQLdb.constants.ER.* |
| FIELD_TYPE_* | MySQLdb.constants.FIELD_TYPE.* |
| FLAG_* | MySQLdb.constants.FLAG.* |
Some _mysql examples
Okay, so you want to use _mysql anyway. Here are some examples.
The simplest possible database connection is:
import _mysql
db=_mysql.connect()
This creates a connection to the MySQL server running on the local machine using the standard UNIX socket (or named pipe on Windows), your login name (from the USER environment variable), no password, and does not USE a database. Chances are you need to supply more information.:
db=_mysql.connect("localhost","joebob","moonpie","thangs")
This creates a connection to the MySQL server running on the local machine via a UNIX socket (or named pipe), the user name "joebob", the password "moonpie", and selects the initial database "thangs".
We haven't even begun to touch upon all the parameters connect() can take. For this reason, I prefer to use keyword parameters:
db=_mysql.connect(host="localhost",user="joebob",
passwd="moonpie",db="thangs")
This does exactly what the last example did, but is arguably easier to read. But since the default host is "localhost", and if your login name really was "joebob", you could shorten it to this:
db=_mysql.connect(passwd="moonpie",db="thangs")
UNIX sockets and named pipes don't work over a network, so if you specify a host other than localhost, TCP will be used, and you can specify an odd port if you need to (the default port is 3306):
db=_mysql.connect(host="outhouse",port=3307,passwd="moonpie",db="thangs")
If you really had to, you could connect to the local host with TCP by specifying the full host name, or 127.0.0.1.
Generally speaking, putting passwords in your code is not such a good idea:
db=_mysql.connect(host="outhouse",db="thangs",read_default_file="~/.my.cnf")
This does what the previous example does, but gets the username and password and other parameters from ~/.my.cnf (UNIX-like systems). Read about option files for more details.
So now you have an open connection as db and want to do a query. Well, there are no cursors in MySQL, and no parameter substitution, so you have to pass a complete query string to db.query():
db.query("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < 5""")
There's no return value from this, but exceptions can be raised. The exceptions are defined in a separate module, _mysql_exceptions, but _mysql exports them. Read DB API specification PEP-249 to find out what they are, or you can use the catch-all MySQLError.
At this point your query has been executed and you need to get the results. You have two options:
r=db.store_result()
# ...or...
r=db.use_result()
Both methods return a result object. What's the difference? store_result() returns the entire result set to the client immediately. If your result set is really large, this could be a problem. One way around this is to add a LIMIT clause to your query, to limit the number of rows returned. The other is to use use_result(), which keeps the result set in the server and sends it row-by-row when you fetch. This does, however, tie up server resources, and it ties up the connection: You cannot do any more queries until you have fetched all the rows. Generally I recommend using store_result() unless your result set is really huge and you can't use LIMIT for some reason.
Now, for actually getting real results:
>>> r.fetch_row()
(('3','2','0'),)
This might look a little odd. The first thing you should know is, fetch_row() takes some additional parameters. The first one is, how many rows (maxrows) should be returned. By default, it returns one row. It may return fewer rows than you asked for, but never more. If you set maxrows=0, it returns all rows of the result set. If you ever get an empty tuple back, you ran out of rows.
The second parameter (how) tells it how the row should be represented. By default, it is zero which means, return as a tuple. how=1 means, return it as a dictionary, where the keys are the column names, or table.column if there are two columns with the same name (say, from a join). how=2 means the same as how=1 except that the keys are always table.column; this is for compatibility with the old Mysqldb module.
OK, so why did we get a 1-tuple with a tuple inside? Because we implicitly asked for one row, since we didn't specify maxrows.
The other oddity is: Assuming these are numeric columns, why are they returned as strings? Because MySQL returns all data as strings and expects you to convert it yourself. This would be a real pain in the ass, but in fact, _mysql can do this for you. (And MySQLdb does do this for you.) To have automatic type conversion done, you need to create a type converter dictionary, and pass this to connect() as the conv keyword parameter.
The keys of conv should be MySQL column types, which in the C API are FIELD_TYPE_*. You can get these values like this:
from MySQLdb.constants import FIELD_TYPE
By default, any column type that can't be found in conv is returned as a string, which works for a lot of stuff. For our purposes, we probably want this:
my_conv = { FIELD_TYPE.LONG: int }
This means, if it's a FIELD_TYPE_LONG, call the builtin int() function on it. Note that FIELD_TYPE_LONG is an INTEGER column, which corresponds to a C long, which is also the type used for a normal Python integer. But beware: If it's really an UNSIGNED INTEGER column, this could cause overflows. For this reason, MySQLdb actually uses long() to do the conversion. But we'll ignore this potential problem for now.
Then if you use db=_mysql.connect(conv=my_conv...), the results will come back ((3, 2, 0),), which is what you would expect.
MySQLdb
MySQLdb is a thin Python wrapper around _mysql which makes it compatible with the Python DB API interface (version 2). In reality, a fair amount of the code which implements the API is in _mysql for the sake of efficiency.
The DB API specification PEP-249 should be your primary guide for using this module. Only deviations from the spec and other database-dependent things will be documented here.
Functions and attributes
Only a few top-level functions and attributes are defined within MySQLdb.
- connect(parameters...)
-
Constructor for creating a connection to the database. Returns a Connection Object. Parameters are the same as for the MySQL C API. In addition, there are a few additional keywords that correspond to what you would pass mysql_options() before connecting. Note that some parameters must be specified as keyword arguments! The default value for each parameter is NULL or zero, as appropriate. Consult the MySQL documentation for more details. The important parameters are:
- host
- name of host to connect to. Default: use the local host via a UNIX socket (where applicable)
- user
- user to authenticate as. Default: current effective user.
- passwd
- password to authenticate with. Default: no password.
- db
- database to use. Default: no default database.
- port
- TCP port of MySQL server. Default: standard port (3306).
- unix_socket
- location of UNIX socket. Default: use default location or TCP for remote hosts.
- conv
- type conversion dictionary. Default: a copy of MySQLdb.converters.conversions
- compress
- Enable protocol compression. Default: no compression.
- connect_timeout
- Abort if connect is not completed within given number of seconds. Default: no timeout (?)
- named_pipe
- Use a named pipe (Windows). Default: don't.
- init_command
- Initial command to issue to server upon connection. Default: Nothing.
- read_default_file
- MySQL configuration file to read; see the MySQL documentation for mysql_options().
- read_default_group
- Default group to read; see the MySQL documentation for mysql_options().
- cursorclass
- cursor class that cursor() uses, unless overridden. Default: MySQLdb.cursors.Cursor. This must be a keyword parameter.
- use_unicode
-
If True, CHAR and VARCHAR and TEXT columns are returned as Unicode strings, using the configured character set. It is best to set the default encoding in the server configuration, or client configuration (read with read_default_file). If you change the character set after connecting (MySQL-4.1 and later), you'll need to put the correct character set name in connection.charset.
If False, text-like columns are returned as normal strings, but you can always write Unicode strings.
This must be a keyword parameter.
- charset
-
If present, the connection character set will be changed to this character set, if they are not equal. Support for changing the character set requires MySQL-4.1 and later server; if the server is too old, UnsupportedError will be raised. This option implies use_unicode=True, but you can override this with use_unicode=False, though you probably shouldn't.
If not present, the default character set is used.
This must be a keyword parameter.
- sql_mode
-
If present, the session SQL mode will be set to the given string. For more information on sql_mode, see the MySQL documentation. Only available for 4.1 and newer servers.
If not present, the session SQL mode will be unchanged.
This must be a keyword parameter.
- ssl
- This parameter takes a dictionary or mapping, where the keys are parameter names used by the mysql_ssl_set MySQL C API call. If this is set, it initiates an SSL connection to the server; if there is no SSL support in the client, an exception is raised. This must be a keyword parameter.
- apilevel
- String constant stating the supported DB API level. '2.0'
- threadsafety
-
Integer constant stating the level of thread safety the interface supports. This is set to 1, which means: Threads may share the module.
The MySQL protocol can not handle multiple threads using the same connection at once. Some earlier versions of MySQLdb utilized locking to achieve a threadsafety of 2. While this is not terribly hard to accomplish using the standard Cursor class (which uses mysql_store_result()), it is complicated by SSCursor (which uses mysql_use_result(); with the latter you must ensure all the rows have been read before another query can be executed. It is further complicated by the addition of transactions, since transactions start when a cursor execute a query, but end when COMMIT or ROLLBACK is executed by the Connection object. Two threads simply cannot share a connection while a transaction is in progress, in addition to not being able to share it during query execution. This excessively complicated the code to the point where it just isn't worth it.
The general upshot of this is: Don't share connections between threads. It's really not worth your effort or mine, and in the end, will probably hurt performance, since the MySQL server runs a separate thread for each connection. You can certainly do things like cache connections in a pool, and give those connections to one thread at a time. If you let two threads use a connection simultaneously, the MySQL client library will probably upchuck and die. You have been warned.
For threaded applications, try using a connection pool. This can be done using the Pool module.
- charset
- The character set used by the connection. In MySQL-4.1 and newer, it is possible (but not recommended) to change the connection's character set with an SQL statement. If you do this, you'll also need to change this attribute. Otherwise, you'll get encoding errors.
- paramstyle
-
String constant stating the type of parameter marker formatting expected by the interface. Set to 'format' = ANSI C printf format codes, e.g. '...WHERE name=%s'. If a mapping object is used for conn.execute(), then the interface actually uses 'pyformat' = Python extended format codes, e.g. '...WHERE name=%(name)s'. However, the API does not presently allow the specification of more than one style in paramstyle.
Note that any literal percent signs in the query string passed to execute() must be escaped, i.e. %%.
Parameter placeholders can only be used to insert column values. They can not be used for other parts of SQL, such as table names, statements, etc.
- conv
-
A dictionary or mapping which controls how types are converted from MySQL to Python and vice versa.
If the key is a MySQL type (from FIELD_TYPE.*), then the value can be either:
- a callable object which takes a string argument (the MySQL value),' returning a Python value
- a sequence of 2-tuples, where the first value is a combination of flags from MySQLdb.constants.FLAG, and the second value is a function as above. The sequence is tested until the flags on the field match those of the first value. If both values are None, then the default conversion is done. Presently this is only used to distinquish TEXT and BLOB columns.
If the key is a Python type or class, then the value is a callable Python object (usually a function) taking two arguments (value to convert, and the conversion dictionary) which converts values of this type to a SQL literal string value.
This is initialized with reasonable defaults for most types. When creating a Connection object, you can pass your own type converter dictionary as a keyword parameter. Otherwise, it uses a copy of MySQLdb.converters.conversions. Several non-standard types are returned as strings, which is how MySQL returns all columns. For more details, see the built-in module documentation.
Connection Objects
Connection objects are returned by the connect() function.
- commit()
- If the database and the tables support transactions, this commits the current transaction; otherwise this method successfully does nothing.
- rollback()
- If the database and tables support transactions, this rolls back (cancels) the current transaction; otherwise a NotSupportedError is raised.
- cursor([cursorclass])
- MySQL does not support cursors; however, cursors are easily emulated. You can supply an alternative cursor class as an optional parameter. If this is not present, it defaults to the value given when creating the connection object, or the standard Cursor class. Also see the additional supplied cursor classes in the usage section.
There are many more methods defined on the connection object which are MySQL-specific. For more information on them, consult the internal documentation using pydoc.
Cursor Objects
- callproc(procname, args)
-
Calls stored procedure procname with the sequence of arguments in args. Returns the original arguments. Stored procedure support only works with MySQL-5.0 and newer.
Compatibility note: PEP-249 specifies that if there are OUT or INOUT parameters, the modified values are to be returned. This is not consistently possible with MySQL. Stored procedure arguments must be passed as server variables, and can only be returned with a SELECT statement. Since a stored procedure may return zero or more result sets, it is impossible for MySQLdb to determine if there are result sets to fetch before the modified parmeters are accessible.
The parameters are stored in the server as @_*procname*_*n*, where n is the position of the parameter. I.e., if you cursor.callproc('foo', (a, b, c)), the parameters will be accessible by a SELECT statement as @_foo_0, @_foo_1, and @_foo_2.
Compatibility note: It appears that the mere act of executing the CALL statement produces an empty result set, which appears after any result sets which might be generated by the stored procedure. Thus, you will always need to use nextset() to advance result sets.
- close()
- Closes the cursor. Future operations raise ProgrammingError. If you are using server-side cursors, it is very important to close the cursor when you are done with it and before creating a new one.
- info()
- Returns some information about the last query. Normally you don't need to check this. If there are any MySQL warnings, it will cause a Warning to be issued through the Python warning module. By default, Warning causes a message to appear on the console. However, it is possible to filter these out or cause Warning to be raised as exception. See the MySQL docs for mysql_info(), and the Python warning module. (Non-standard)
- setinputsizes()
- Does nothing, successfully.
- setoutputsizes()
- Does nothing, successfully.
- nextset()
-
Advances the cursor to the next result set, discarding the remaining rows in the current result set. If there are no additional result sets, it returns None; otherwise it returns a true value.
Note that MySQL doesn't support multiple result sets until 4.1.
Some examples
The connect() method works nearly the same as with _mysql:
import MySQLdb
db=MySQLdb.connect(passwd="moonpie",db="thangs")
To perform a query, you first need a cursor, and then you can execute queries on it:
c=db.cursor()
max_price=5
c.execute("""SELECT spam, eggs, sausage FROM breakfast
WHERE price < %s""", (max_price,))
In this example, max_price=5 Why, then, use %s in the string? Because MySQLdb will convert it to a SQL literal value, which is the string '5'. When it's finished, the query will actually say, "...WHERE price < 5".
Why the tuple? Because the DB API requires you to pass in any parameters as a sequence. Due to the design of the parser, (max_price) is interpreted as using algebraic grouping and simply as max_price and not a tuple. Adding a comma, i.e. (max_price,) forces it to make a tuple.
And now, the results:
>>> c.fetchone()
(3L, 2L, 0L)
Quite unlike the _mysql example, this returns a single tuple, which is the row, and the values are properly converted by default... except... What's with the L's?
As mentioned earlier, while MySQL's INTEGER column translates perfectly into a Python integer, UNSIGNED INTEGER could overflow, so these values are converted to Python long integers instead.
If you wanted more rows, you could use c.fetchmany(n) or c.fetchall(). These do exactly what you think they do. On c.fetchmany(n), the n is optional and defaults to c.arraysize, which is normally 1. Both of these methods return a sequence of rows, or an empty sequence if there are no more rows. If you use a weird cursor class, the rows themselves might not be tuples.
Note that in contrast to the above, c.fetchone() returns None when there are no more rows to fetch.
The only other method you are very likely to use is when you have to do a multi-row insert:
c.executemany(
"""INSERT INTO breakfast (name, spam, eggs, sausage, price)
VALUES (%s, %s, %s, %s, %s)""",
[
("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),
("Not So Much Spam Plate", 3, 2, 0, 3.95 ),
("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )
] )
Here we are inserting three rows of five values. Notice that there is a mix of types (strings, ints, floats) though we still only use %s. And also note that we only included format strings for one row. MySQLdb picks those out and duplicates them for each row.
Using and extending
In general, it is probably wise to not directly interact with the DB API except for small applicatons. Databases, even SQL databases, vary widely in capabilities and may have non-standard features. The DB API does a good job of providing a reasonably portable interface but some methods are non-portable. Specifically, the parameters accepted by connect() are completely implementation-dependent.
If you believe your application may need to run on several different databases, the author recommends the following approach, based on personal experience: Write a simplified API for your application which implements the specific queries and operations your application needs to perform. Implement this API as a base class which should be have few database dependencies, and then derive a subclass from this which implements the necessary dependencies. In this way, porting your application to a new database should be a relatively simple matter of creating a new subclass, assuming the new database is reasonably standard.
Because MySQLdb's Connection and Cursor objects are written in Python, you can easily derive your own subclasses. There are several Cursor classes in MySQLdb.cursors:
- BaseCursor
- The base class for Cursor objects. This does not raise Warnings.
- CursorStoreResultMixIn
- Causes the Cursor to use the mysql_store_result() function to get the query result. The entire result set is stored on the client side.
- CursorUseResultMixIn
- Causes the cursor to use the mysql_use_result() function to get the query result. The result set is stored on the server side and is transferred row by row using fetch operations.
- CursorTupleRowsMixIn
- Causes the cursor to return rows as a tuple of the column values.
CursorDictRowsMixIn
Causes the cursor to return rows as a dictionary, where the keys are column names and the values are column values. Note that if the column names are not unique, i.e., you are selecting from two tables that share column names, some of them will be rewritten as table.column. This can be avoided by using the SQL AS keyword. (This is yet-another reason not to use * in SQL queries, particularly where JOIN is involved.)
- Cursor
- The default cursor class. This class is composed of CursorWarningMixIn, CursorStoreResultMixIn, CursorTupleRowsMixIn, and BaseCursor, i.e. it raises Warning, uses mysql_store_result(), and returns rows as tuples.
- DictCursor
- Like Cursor except it returns rows as dictionaries.
- SSCursor
- A "server-side" cursor. Like Cursor but uses CursorUseResultMixIn. Use only if you are dealing with potentially large result sets.
- SSDictCursor
- Like SSCursor except it returns rows as dictionaries.
Embedded Server
Instead of connecting to a stand-alone server over the network, the embedded server support lets you run a full server right in your Python code or application server.
If you have built MySQLdb with embedded server support, there are two additional functions you will need to make use of:
- server_init(args, groups)
Initialize embedded server. If this client is not linked against the embedded server library, this function does nothing.
- args
- sequence of command-line arguments
- groups
- sequence of groups to use in defaults files
- server_end()
- Shut down embedded server. If not using an embedded server, this does nothing.
See the MySQL documentation for more information on the embedded server.
| Title: | MySQLdb: a Python interface for MySQL |
|---|---|
| Author: | Andy Dustman |
| Version: | $Revision: 421 $ |
]]>
1、下载MySQL 5.x 发行?Q解压ƈ安装映像中的两个安装包文件?/p>
a. mysql-5.x-osx10.6_x86_64.pkg Qmysql 5.x 标准版安?/p>
b. MySQLStartupItem.pkgQmysql启动目Q可以上你的?sh)脑在启动系l时自动q行mysql服务。它安装?Library /StartupItems/MySQL/Q如果你不想pȝ启动时运行mysql服务Q请不要安装。如果你在安装后又不想用，请删?Library /StartupItems/MySQL/q个目录?/p>
启动mysqlQ?/p>
2、如果你已经安装?jin)MySQLStartupItem.pkgQ重新启动电(sh)脑即可?/p>
3、如果你有安装MySQLStartupItem.pkg或者不惛_动电(sh)脑，q行Q应用程序－实用E序Q终端程序，在终端中输入命o(h)Q?/p>
sudo /Library/StartupItems/MySQL/MySQL start
然后输入你的pȝ理员密码，如果没有讑֮密码q接回车?/p>
关闭mysql服务Q?/p>
l端中输入命令：(x)sudo /Library/StartupItems/MySQL/MySQL stop
然后输入你的pȝ理员密码，如果没有讑֮密码q接回车?/p>
mysql root账户密码Q?/p>
mysql root密码初始值是I。这栯然没有问题。但很不安全。徏议你更改root用户密码。注意：(x)mysql root用户和系l中的root用户是不一L(fng)。是完全两个不同的用戗?/p>
更改mysql root密码请在l端中输入命令：(x)
/usr/local/mysql/bin/mysqladmin -u root password 新密?/p>
同时你也可以随时使用q条命o(h)更改你的密码?/p>
4、下载x版mysql数据库管理工?/p>
q是一个运行在mac os
xpȝ中的mysql数据库管理YӞ支持本地?qing)远E数据库理。ƈ且还是免费的。这个程序的优点是完全CGI界面。ƈ且密码是保存在本Z的。相Ҏ(gu)?
安全?/p>
Solution: Uninstall ipv6 from Network management.
]]>
]]>
sql1 as (select to_char(a) s_name from test_tempa),
sql2 as (select to_char(b) s_name from test_tempb where not exists (select s_name from sql1 where rownum=1))
select * from sql1
union all
select * from sql2
union all
select 'no records' from dual
where not exists (select s_name from sql1 where rownum=1)
and not exists (select s_name from sql2 where rownum=1);
再D个简单的例子
with a as (select * from test)
select * from a;
其实是把一大堆重复用到的SQL语句攑֜with as 里面Q取一个别名，后面的查询就可以用它
q样对于大批量的SQL语句起到一个优化的作用Q而且清楚明了(jin)
as 的好?
The SQL “WITH clause” is very similar to the use of Global temporary tables (GTT), a technique that is often used to improve query speed for complex subqueries. Here are some important notes about the Oracle “WITH clause”:
• The SQL “WITH clause” only works on Oracle 9i release 2 and beyond.
• Formally, the “WITH clause” is called subquery factoring
• The SQL “WITH clause” is used when a subquery is executed multiple times
• Also useful for recursive queries (SQL-99, but not Oracle SQL)
To keep it simple, the following example only references the aggregations once, where the SQL “WITH clause” is normally used when an aggregation is referenced multiple times in a query.
The SQL-99 “WITH clause” is very confusing at first because the SQL statement does not begin with the word SELECT. Instead, we use the “WITH clause” to start our SQL query, defining the aggregations, which can then be named in the main query as if they were “real” tables:
WITH
subquery_name
AS
(the aggregation SQL statement)
SELECT
(query naming subquery_name);
Retuning to our oversimplified example, let’s replace the temporary tables with the SQL “WITH clause”:
WITH
sum_sales AS
select /*+ materialize */
sum(quantity) all_sales from stores
number_stores AS
select /*+ materialize */
count(*) nbr_stores from stores
sales_by_store AS
select /*+ materialize */
store_name, sum(quantity) store_sales from
store natural join sales
SELECT
store_name
FROM
store,
sum_sales,
number_stores,
sales_by_store
where
store_sales > (all_sales / nbr_stores)
;
Note the use of the Oracle undocumented “materialize” hint in the “WITH clause”. The Oracle materialize hint is used to ensure that the Oracle cost-based optimizer materializes the temporary tables that are created inside the “WITH” clause. This is not necessary in Oracle10g, but it helps ensure that the tables are only created one time.
It should be noted that the “WITH clause” does not yet fully-functional within Oracle SQL and it does not yet support the use of “WITH clause” replacement for “CONNECT BY” when performing recursive queries.
To see how the “WITH clause” is used in ANSI SQL-99 syntax, here is an excerpt from Jonathan Gennick’s great work “Understanding the WITH Clause” showing the use of the SQL-99 “WITH clause” to traverse a recursive bill-of-materials hierarchy
The SQL-99 “WITH clause” is very confusing at first because the SQL statement does not begin with the word SELECT. Instead, we use the “WITH clause” to start our SQL query, defining the aggregations, which can then be named in the main query as if they were “real” tables:
WITH
subquery_name
AS
(the aggregation SQL statement)
SELECT
(query naming subquery_name);
Retuning to our oversimplified example, let’s replace the temporary tables with the SQL “WITH” clause”:
另一个例?
with tempDeptName(deptName) as
(
select
dept_name as deptName
from
bas_dept as dept,tpp_materialmuster as muster
where
dept.DEPT_ID = muster.NEEDUNIT
union all
select
corp_name as deptName
from
bas_corp as corp,tpp_materialmuster as muster
where
corp.corp_id = muster.NEEDUNIT
),
tempProjInfo(projName, projCode) as
(
select
etfprojName as projName,
etfprojCode as projCode
from
tbi_etfproj as etf, tpp_materialMuster as muster
where
etf.etfprojid = muster.projid
union all
select
etmprojName as projName,
etmprojCode as projCode
from
tbi_etmproj as etm, tpp_materialMuster as muster
where
etm.etmprojId = muster.projid
)
select
deptname,
projname,
projcode
from tpp_materialmuster as muster,tempDeptName,tempProjInfo
]]>
]]>
import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;
/*
* 该类只能创徏一个实例，其它对象能够调用光(rn)态方法（也称为类Ҏ(gu)Q获得该唯一实例的引用?br />
* DBConnectionManagercȝ建构函数是私有的Q这是ؓ(f)?jin)避免其它对象创cȝ实例.
* DBConnectionManagercȝ客户E序可以调用getInstance()Ҏ(gu)获得对该cd一实例的引用?br />
* cȝ唯一实例在getInstance()Ҏ(gu)W一ơ被调用期间创徏Q此后其引用׃直保存在?rn)态变?br />
* instance中。每ơ调用getInstance()都增加一个DBConnectionManager的客L(fng)序计数?br />
* 卻I该计C表引用DBConnectionManager唯一实例的客L(fng)序LQ它?yu)被用于控制q接池的
* 关闭操作?该类实例的初始化工作U有Ҏ(gu)init()完成。其?getResourceAsStream()Ҏ(gu)
* 用于定位q打开外部文g。外部文件的定位Ҏ(gu)依赖于类装蝲器的实现。标准的本地c装载器查找?br />
* 作L开始于cL件所在\径，也能够搜索CLASSPATH中声明的路径。db.properties是一个属?br />
* 文gQ它包含定义q接池的?值对。可供定义的公用属性如下：(x)
* drivers 以空格分隔的JDBC驱动E序cd?"
* logfile 日志文g的绝对\?
* 其它的属性和特定q接池相养I其属性名字前应加上连接池名字Q?
* < poolname>.url 数据库的 JDBC URL
* < poolname>.maxconn 允许建立的最大连接数Q?表示没有限制
* < poolname>.user 用于该连接池的数据库帐号
* < poolname>.password 相应的密?"
* 其中url属性是必需的，而其它属性则是可选的。数据库帐号和密码必d法。用于Windowsq_?br />
* db.properties文gCZ如下Q?br />
* drivers=com.microsoft.jdbc.sqlserver.SQLServerDriver
* logfile=D:""log.txt
* access.maxconn=20
* access.url=jdbc:microsoft:sqlserver://localhost:1433;databasename=web
* access.user=sa
* access.password=sa
* 注意在Windows路径中的反斜杠必输?个，q是׃属性文件中的反斜杠同时也是一个{义字W?br />
* init()Ҏ(gu)在创建属性对象ƈddb.properties文g之后Q就开始检查logfile属性。如果属
* 性文件中没有指定日志文gQ则默认为当前目录下的DBConnectionManager.log文g。如日志?br />
* 件无法用，则向System.err输出日志记录。装载和注册所有在drivers属性中指定的JDBC驱动
* E序loadDrivers()Ҏ(gu)实现。该Ҏ(gu)先用StringTokenizerdrivers属性值分割ؓ(f)对应于驱
* 动程序名U的字符Ԍ然后依次装蝲q些cdƈ创徏其实例，最后在DriverManager中注册该实例q把
* 它加入到一个私有的向量drivers。向量drivers用于关闭服务时从DriverManager取消所?br />
* JDBC 驱动E序的注册。init()Ҏ(gu)的最后一个Q务是调用U有Ҏ(gu)createPools()创徏q接池对
* 象。createPools()Ҏ(gu)先创建所有属性名字的枚D对象Q即Enumeration对象Q该对象可以惌
* Z个元素系列，逐次调用其nextElement()Ҏ(gu)顺序返回各元素Q，然后在其中搜索名字以“.url”
* l尾的属性。对于每一个符合条件的属性，先提取其q接池名字部分，q而读取所有属于该q接池的属性，
* 最后创接池对象q把它保存在实例变量pools中。散列表QHashtablec?Qpools实现q接池名?br />
* 到连接池对象之间的映，此处以连接池名字为键Q连接池对象为倹{?Z于客L(fng)序从指定q接池获
* 得可用连接或连接返回给q接池，cDBConnectionManager提供?jin)方法getConnection()?br />
* freeConnection()。所有这些方法都要求在参C指定q接池名字，具体的连接获取或q回操作则调
* 用对应的q接池对象完成。ؓ(f)实现q接池的安全关闭QDBConnectionManager提供?jin)方法r(sh)elease()?br />
* 在上面我们已l提刎ͼ所有DBConnectionManager的客L(fng)序都应该调用?rn)态方法getInstance()
* 以获得该理器的引用Q此调用增加客L(fng)序计数。客L(fng)序在关闭时调用release()可以递减该计数?br />
* 当最后一个客L(fng)序调用release()Q递减后的引用计数?Q就可以调用各个q接池的release()Ҏ(gu)
* 关闭所有连接了(jin)。管理类release()Ҏ(gu)最后的d是撤销所有JDBC驱动E序的注册?br />
*/
/**
* 理cDBConnectionManager支持对一个或多个由属性文件定义的数据库连?br />
* 池的讉K.客户E序可以调用getInstance()Ҏ(gu)讉K本类的唯一实例.
*/
public class DBConnectionManager {
static private DBConnectionManager instance; // 唯一实例
static private int clients;
private Vector drivers = new Vector();
private PrintWriter log;
private Hashtable pools = new Hashtable();
/**
* q回唯一实例.如果是第一ơ调用此Ҏ(gu),则创建实?br />
* @return DBConnectionManager 唯一实例
*/
static synchronized public DBConnectionManager getInstance() {
if (instance == null) {
instance = new DBConnectionManager();
}
clients++;
return instance;
}
/**
* 建构函数U有以防止其它对象创建本cd?br />
*/
private DBConnectionManager() {
init();
}
/**
* * 连接对象返回给由名字指定的q接?br />
* @param name在属性文件中定义的连接池名字
* @param conq接对象""""r
*/
public void freeConnection(String name, Connection con) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
pool.freeConnection(con);
}
}
/**
* 获得一个可用的(I闲?q接.如果没有可用q接,且已有连接数于最大连接数 053 * 限制,则创建ƈq回新连
* @param name在属性文件中定义的连接池名字 056 *
* @return Connection 可用q接或null 057
*/
public Connection getConnection(String name) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
return pool.getConnection();
}
return null;
}
/**
* 获得一个可用连?若没有可用连?且已有连接数于最大连接数限制,
* 则创建ƈq回新连?否则,在指定的旉内等待其它线E释放连?
* @param name q接池名?071 *
* @param time以毫U计的等待时?a>""""r
* @return Connection 可用q接或null
*/
public Connection getConnection(String name, long time) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
return pool.getConnection(time);
}
return null;
}
/**
* 关闭所有连?撤销驱动E序的注?a>""""r
*/
public synchronized void release() {
// {待直到最后一个客L(fng)序调?br />
if (--clients != 0) {
return;
}
Enumeration allPools = pools.elements();
while (allPools.hasMoreElements()) {
DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
pool.release();
}
Enumeration allDrivers = drivers.elements();
while (allDrivers.hasMoreElements()) {
Driver driver = (Driver) allDrivers.nextElement();
try {
DriverManager.deregisterDriver(driver);
log("撤销JDBC驱动E序 " + driver.getClass().getName() + "的注?);
} catch (SQLException e) {
log(e, "无法撤销下列JDBC驱动E序的注? " + driver.getClass().getName());
}
}
}
/**
* Ҏ(gu)指定属性创接池实例.
* @param props q接池属?113
*/
private void createPools(Properties props) {
Enumeration propNames = props.propertyNames();
while (propNames.hasMoreElements()) {
String name = (String) propNames.nextElement();
if (name.endsWith(".url")) {
String poolName = name.substring(0, name.lastIndexOf("."));
String url = props.getProperty(poolName + ".url");
if (url == null) {
log("没有接池" + poolName + "指定URL");
continue;
}
String user = props.getProperty(poolName + ".user");
String password = props.getProperty(poolName + ".password");
String maxconn = props.getProperty(poolName + ".maxconn", "0");
int max;
try {
max = Integer.valueOf(maxconn).intValue();
} catch (NumberFormatException e) {
log("错误的最大连接数限制: " + maxconn + " .q接? " + poolName);
max = 0;
}
DBConnectionPool pool = new DBConnectionPool(poolName, url,
user, password, max);
pools.put(poolName, pool);
log("成功创徏q接? + poolName);
}
}
}
/**
* d属性完成初始化
*/
private void init() {
InputStream is = getClass().getResourceAsStream("/db.properties");
Properties dbProps = new Properties();
try {
dbProps.load(is);
} catch (Exception e) {
System.err.println("不能d属性文? "+"L(fng)保db.properties在CLASSPATH指定的\径中");
return;
}
String logFile = dbProps.getProperty("logfile","DBConnectionManager.log");
try {
log = new PrintWriter(new FileWriter(logFile, true), true);
} catch (IOException e) {
System.err.println("无法打开日志文g: " + logFile);
log = new PrintWriter(System.err);
}
loadDrivers(dbProps);
createPools(dbProps);
}
/**
* 装蝲和注册所有JDBC驱动E序
* @param props属?br />
*/
private void loadDrivers(Properties props) {
String driverClasses = props.getProperty("drivers");
StringTokenizer st = new StringTokenizer(driverClasses);
while (st.hasMoreElements()) {
String driverClassName = st.nextToken().trim();
try {
Driver driver = (Driver) Class.forName(driverClassName).newInstance();
DriverManager.registerDriver(driver);
drivers.addElement(driver);
log("成功注册JDBC驱动E序" + driverClassName);
} catch (Exception e) {
e.printStackTrace();
log("无法注册JDBC驱动E序: " + driverClassName + ", 错误: " + e);
}
}
}
/**
* 文本信息写入日志文?br />
*/
private void log(String msg) {
log.println(new Date() + ": " + msg);
}
/**
* 文本信息与异常写入日志文g
*/
private void log(Throwable e, String msg) {
log.println(new Date() + ": " + msg);
e.printStackTrace(log);
}
// ///////////////////////////////////////////////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* DBConnectionPool实现Q它表示指向某个数据库的q接池。数据库由JDBC URL标识。一个JDBCURL׃部分l成Q协议标识（LjdbcQ，
* 驱动E序标识Q如odbc、idb、oracle{）(j)Q数据库标识Q其格式依赖于驱动程序）(j)。例如，jdbc:odbc:demoQ即是一个指向demo数据
* 库的JDBCURLQ而且讉K该数据库要用JDBC-ODBC驱动E序。每个连接池都有一个供客户E序使用的名字以?qing)可选的用户帐号、密码、最
* 大连接数限制。如果Web应用E序所支持的某些数据库操作可以被所有用h行，而其它一些操作应q别许可的用户执行Q则可以ZcL?br />
* 分别定义q接池，两个q接池用相同的JDBC URLQ但使用不同的帐号和密码。类DBConnectionPool的徏构函数需要上q所有数据作为其
* 参数。客L(fng)序可以用DBConnectionPool
* cL供的两个Ҏ(gu)获取可用q接。两者的共同之处在于Q如q接池中存在可用q接Q则直接q回Q否则创建新的连接ƈq回。如果没有可用连?br />
* 且已有连接L{于最大限制数Q第一个方法将直接q回nullQ而第二个Ҏ(gu)等待直到有可用q接为止。所有的可用q接对象均登记在名ؓ(f)
* freeConnections的向量（VectorQ中。如果向量中有多于一个的q接QgetConnection()L选取W一个。同Ӟ׃新的可用q接?br />
* 是从N加入向量Q从而得数据库q接׃长时间闲|而被关闭的风险减低到最程度?W一个getConnection()在返回可用连接给客户
* E序之前Q调用了(jin)isClosed()Ҏ(gu)验证q接仍旧有效。如果该q接被关闭或触发异常QgetConnection()递归地调用自׃试获取另外?br />
* 可用q接。如果在向量freeConnections中不存在M可用q接QgetConnection()Ҏ(gu)(g)查是否已l指定最大连接数限制。如已经指定Q?br />
* 则检查当前连接数是否已经到达极限。此处maxConn?表示没有限制。如果没有指定最大连接数限制或当前连接数于该|该方法尝试创?br />
* 新的q接。如创徏成功Q则增加已用连接的计数q返回，否则q回I倹{创建新q接由newConnection()Ҏ(gu)实现?br />
* 创徏q程与是否已l指定数据库帐号、密码有兟뀂JDBC的DriverManagercL供多个getConnection()Ҏ(gu)Q这些方法要用到JDBC URL
* 与其它一些参敎ͼ如用户帐号和密码{。DriverManager用指定的JDBC URL定适合于目标数据库的驱动程序及(qing)建立q接?br />
* W二个getConnection()Ҏ(gu)需要一个以毫秒为单位的旉参数Q该参数表示客户E序能够{待的最长时间。徏立连接的具体?br />
* 作仍旧由W一个getConnection()Ҏ(gu)实现。该Ҏ(gu)执行时先startTime初始化ؓ(f)当前旉。在while循环中尝试获得一个连接。如果失
* 败，则以l定的时间gؓ(f)参数调用wait()。wait()的返回可能是׃其它U程调用notify()或notifyAll()Q也可能是由于预定时间已到?br />
* 为找出wait()q回的真正原因，E序用当前时间减开始时_(d)startTimeQ，如差值大于预定时间则q回I|否则再次调用getConnection()?br />
* 把空闲的q接登记到连接池由freeConnection()Ҏ(gu)实现Q它的参Cؓ(f)q回l连接池的连接对象。该对象被加入到freeConnections
* 向量的末，然后减少已用连接计数。调用notifyAll()是ؓ(f)?jin)通知其它正在{待可用q接的线E?许多Servlet引擎为实现安全关闭提?br />
* 多种Ҏ(gu)。数据库q接池需要知道该事g以保证所有连接能够正常关闭。DBConnectionManagerc负协调整个关闭q程Q但关闭q接池中所有连
* 接的d则由DBConnectionPoolc负责。release()Ҏ(gu)供DBConnectionManager调用。该Ҏ(gu)遍历freeConnections向量q关闭所有连接，
* 然后从向量中删除q些q接?br />
*/
/**
* 此内部类定义?jin)一个连接池.它能够根据要求创建新q接,直到预定的最""""r
*/
class DBConnectionPool {
private int checkedOut;
private Vector freeConnections = new Vector();
private int maxConn;
private String name;
private String password;
private String URL;
private String user;
/**
* 创徏新的q接?br />
* @param nameq接池名?br />
* @param URL数据库的JDBC URL
* @param user数据库帐??null
* @param password密码,?null
* @param maxConn此连接池允许建立的最大连接数
*/
public DBConnectionPool(String name, String URL, String user,
String password, int maxConn) {
this.name = name;
this.URL = URL;
this.user = user;
this.password = password;
this.maxConn = maxConn;
}
/**
* 不再用的q接q回l连接池
* @param con客户E序释放的连?br />
*/
public synchronized void freeConnection(Connection con) {
// 指定连接加入到向量末尾
freeConnections.addElement(con);
checkedOut--;
notifyAll();
}
/**
* 从连接池获得一个可用连?如没有空闲的q接且当前连接数于最大连?数限?则创建新q接.
* 如原来登Cؓ(f)可用的连接不再有?则从向量删除?
* 然后递归调用自己以尝试新的可用连?
*/
public synchronized Connection getConnection() {
Connection con = null;
if (freeConnections.size() > 0) {// 获取向量中第一个可用连?br />
con = (Connection) freeConnections.firstElement();
freeConnections.removeElementAt(0);
try {
if (con.isClosed()) {
log("从连接池" + name + "删除一个无效连?);
// 递归调用自己,试再次获取可用q接
con = getConnection();
}
} catch (SQLException e) {
log("从连接池" + name + "删除一个无效连?);
// 递归调用自己,试再次获取可用q接
con = getConnection();
}
} else if (maxConn == 0 || checkedOut < maxConn) {
con = newConnection();
}
if (con != null) {
checkedOut++;
}
return con;
}
/**
* 从连接池获取可用q接.可以指定客户E序能够{待的最长时?参见前一个getConnection()Ҏ(gu).
* @param timeout以毫U计的等待时间限?br />
*/
public synchronized Connection getConnection(long timeout) {
long startTime = new Date().getTime();
Connection con;
while ((con = getConnection()) == null) {
try {
wait(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
if ((new Date().getTime() - startTime) >= timeout) {// wait()q回的原因是时
return null;
}
}
return con;
}
/**
* 关闭所有连?br />
*/
public synchronized void release() {
Enumeration allConnections = freeConnections.elements();
while (allConnections.hasMoreElements()) {
Connection con = (Connection) allConnections.nextElement();
try {
con.close();
log("关闭q接? + name + "中的一个连?);
} catch (SQLException e) {
log(e, "无法关闭q接? + name + "中的q接");
e.printStackTrace();
}
}
freeConnections.removeAllElements();
}
/**
* 创徏新的q接
*/
private Connection newConnection() {
Connection con = null;
try {
if (user==null||"".equals(user)) {
con = DriverManager.getConnection(URL);
} else {
con = DriverManager.getConnection(URL, user, password);
}
log("q接? + name + "创徏一个新的连?);
} catch (SQLException e) {
log(e, "无法创徏下列URL的连? " + URL);
return null;
}
return con;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
}
在sqlserver2000Qtomcat5.5验证通过
Ҏ(gu)调用Q?/p>
package com.xinnuo.jdbc;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
private DBConnectionManager connMgr = null;
private Connection conn = null;
private Statement stat = null;
private ResultSet rs = null;
public DBConn() {
connMgr = DBConnectionManager.getInstance();
}
public ResultSet executeQuery(String strSQL) throws SQLException {
this.conn = connMgr.getConnection("access");
this.stat = this.conn.createStatement();
this.rs = this.stat.executeQuery(strSQL);
return this.rs;
}
public void execute(String strSQL) throws SQLException {
this.conn = connMgr.getConnection("access");
this.stat = this.conn.createStatement();
this.stat.execute(strSQL);
}
public void executeUpdate(String strSQL) throws SQLException {
this.conn = connMgr.getConnection("access");
this.stat = this.conn.createStatement();
this.stat.executeUpdate(strSQL);
}
public Connection getConnection(){
this.conn = connMgr.getConnection("access");
return this.conn;
}
public void free(){
try {
if (this.rs != null) {
this.rs.close();
}
if (this.stat != null) {
this.stat.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
connMgr.freeConnection("access", this.conn);
}
}
]]>
]]>
]]>
?“开?#8221; --> “q行”中输?regeditQ开启注册表~辑器?br />
定位?br /> [HKEY_LOCAL_MACHINE"SOFTWARE"Microsoft"Windows NT"CurrentVersion"Perflib
处，在右边的?wi)Ş目录下可以看到Perflib目录下有004?09两个子目录?br />
在Sql Server 2005 的安装帮助文件中说的是需要查?09目录的注册表，而我们大部分Z用的是简体中文的操作pȝQ所以不能按帮助中说的，而是需要注?04目录中的内容?br />
打开004 目录中的内容Q可以看到如下图Q?br />
我们分别双击 “Counter” ??“Help” ，察看其中的最后的数字Q如下图Q?br />
Counter 的内容Q?br />
Helper 内?br />
q时候，我们知道QCounter 的数字?556QHelper的内容?557?br />
然后Q操作注册表~辑器的左边的目录树(wi)Q定位到Perflib目录下，q注意检查右边窗口的 “Laster Counter”和“Laster Help”的|q把Laster Counter的值改成刚才记录下的Counter?556Q把Laster Help 的值改成刚才记下的 Help的?557?br />
要注意的是，修改数字的时候，输入的时候必选则基数?“十进?#8221;Q否则数字将不匹配，Sql Server 2005 (g)查将再次p|?br />
然后关闭注册表编辑器Q开始安?Sql Server 2005 Q绝对可以安装成功?
]]>
1>mysql安装文g(本h使用mysql5.0.51a-linux-i686-glibc23.tar.gz)解压到对应目录，在此?/home/seal/mysql
2>q入源码目录~译安装
CODE:
#cd /home/seal/mysql
#./configure --prefix=/usr/local/mysql --with-charset=gbk |?配置Mysql安装路径q且支持中文
#make |?~译
#make install |?~译安装
3>替换/etc/my.cnf文g,q入源码?执行命o(h)
CODE:
#cd /home/seal/mysql
#cp support-files/my-medium.cnf /etc/my.cnf
4>建立MySQL使用者和组:
CODE:
#groupadd mysql#useradd -g mysql mysql
5>完成以上操作以后q行初始化数据库,q入已经安装好的mysql目录
CODE:
#cd /usr/local/mysql
#bin/mysql_install_db --user=mysql |?--user=mysql 初始化表q且规定用mysql用户
6>讄lmysql和root用户讑֮讉K权限 我们先进入mysql目录
CODE:
#cd /usr/local/mysql
#chown -R root /usr/local/mysql |?讑֮root能访?usr/local/mysq
#chown -R mysql /usr/local/mysql/var |?讑֮mysql用户能访?usr/local/mysql/var
#chgrp -R mysql /usr/local/mysql |?讑֮mysqll能够访?usr/local/mysq
7>启动mysql,q入已经安装好的目录
CODE:
#cd /usr/local/mysql
#bin/mysqld_safe --user=mysql &
8>
修改mysql数据库超U用户root的缺省密?
/usr/local/mysql/bin/mysqladmin -u root password 'mysql'
关闭mysql服务?
cd /usr/local/mysql/bin
./mysqladmin -u root -p shutdown
9>讑֮开机就启动mysql,q入源码目录?/p>
# cd /home/seal/mysql
# cp support-files/mysql.server /etc/init.d/mysql
# chkconfig --level 345 mysql on
# service mysql restart
Shutting down MySQL. [ 定 ]
Starting MySQL [ 定 ]
[root@localhost mysql]#
10>讄Mysqlq程讉KQ?br /> 在启动mysql后：(x)
mysql>GRANT ALL PRIVILEGES ON *.* TO ‘myuser’@'%’ IDENTIFIED BY ‘mypassword’ WI
TH GRANT OPTION;
mysql>Flush Privileges;
安装完毕?br />
]]>
解决Ҏ(gu)Q?/span>
1?/span>改表法。可能是你的帐号不允总q程登陆Q只能在localhost。这个时候只要在localhost的那台电(sh)脑，dmysql后，更改 “mysql” 数据库里?/span> “user” 表里?/span> “host” ，?/span>“localhost”改称“%”
|
mysql -u root -pvmwaremysql>use mysql; |
2. 授权法。例如，你想myuser使用mypassword从Q何主接到mysql服务器的话?/span>
|
GRANT ALL PRIVILEGES ON *.* TO ‘myuser’@'%’ IDENTIFIED BY ‘mypassword’ WI |
如果你想允许用户myuser?/span>ip?/span>192.168.1.6的主接到mysql服务器，q?/span>mypassword作ؓ(f)密码
|
GRANT ALL PRIVILEGES ON *.* TO ‘myuser’@'192.168.1.3′ IDENTIFIED BY |
使修改生?/span>.可以了(jin)
]]>
l过几小时的?zhun)扎Q在配置理器里面发C(jin)问题Q原来是TCPIP服务没有默认打开Q解军_下：(x)
1、打开SQL Server Configuration Manager -> Protocols for SQLEXPRESS -> TCP/IP
2、右键单d动TCP/IP
3、双击进入属性，把IP地址中的IP all中的TCP端口讄?433
4、重新启动SQL Server 2005服务
]]>
执行“ALTER TABLE table1 DROP COLUMN column1”时就?x)报错?x)
The object 'DF__xxxxxxxxxxx' is dependent on column 'column1'.
ALTER TABLE DROP COLUMN column1failed because one or more objects access this column.
所以在删除此字D|需要先系l表中的对应默认U束删除Q?可以使用下面的脚本进行删除：(x)
-- this script drops the default constraint which is generated by the setting of default value.
DECLARE @tablename VARCHAR(100), @columnname VARCHAR(100), @tab VARCHAR(100)
SET @tablename='CountryGroupEmailAndWaitAux'
SET @columnname='actionOfHasNoValidEmail'
declare @defname varchar(100)
declare @cmd varchar(100)
select @defname = name
FROM sysobjects so
JOIN sysconstraints sc
ON so.id = sc.constid
WHERE object_name(so.parent_obj) = @tablename
AND so.xtype = 'D'
AND sc.colid =
(SELECT colid FROM syscolumns
WHERE id = object_id(@tablename) AND
name = @columnname)
select @cmd='alter table '+ @tablename+ ' drop constraint '+ @defname
if @cmd is null print 'No default constraint to drop'
exec (@cmd)
在删除对应的默认U束后，执行Q?br /> ALTER TABLE table1 DROP COLUMN column1
卛_删除字段?br />
]]>
数据库结构的脚本:
if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[TempA]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[TempA]
GO
CREATE TABLE [dbo].[TempA] (
[id] [int] IDENTITY (1, 1) NOT NULL ,
[PositionName] [varchar] (256) COLLATE Chinese_PRC_CI_AS NULL ,
[EnglishPositionName] [varchar] (256) COLLATE Chinese_PRC_CI_AS NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[TempA] ADD
CONSTRAINT [PK_TempA] PRIMARY KEY CLUSTERED
(
[id]
) ON [PRIMARY]
GO
TempA表中有三个字D?id唯一且ؓ(f)主键,自动增长; PositionName,EnglishPositionName中有重复的记?比如:
id PositionName EnglishPositionName
20 其他 Others
21 质量工程?nbsp; QC Engineer
22 其他 Others
.......
100 质量工程?nbsp; QC Engineer
需要剔除重复的"其他","质量工程?{记录?/p>
采用的SQL语句Q?br />
Delete from TempA where id not in (
select max(t1.id) from TempA t1 group by
t1.PositionName,t1.EnglishPositionName)
说明Q?br />
(1)需要剔除那几个用于判断重复的字D，则将它们攑֜group by语句之后?br />
(2)max(t1.id) 也可以改成：(x)min(t1.id)
]]>