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銆佷笅杞組ySQL 5.x 鍙戣鐗?錛岃В鍘嬪茍瀹夎鏄犲儚涓殑涓や釜瀹夎鍖呮枃浠躲?/p>
銆銆a. mysql-5.x-osx10.6_x86_64.pkg 錛峬ysql 5.x 鏍囧噯鐗堝畨瑁?/p>
銆銆b. MySQLStartupItem.pkg錛峬ysql鍚姩欏圭洰錛屽彲浠ヤ笂浣犵殑鐢?shù)鑴戝湪鍚姩绯痪l熸椂鑷姩榪愯mysql鏈嶅姟銆傚畠瀹夎鍦?Library /StartupItems/MySQL/錛屽鏋滀綘涓嶆兂緋葷粺鍚姩鏃惰繍琛宮ysql鏈嶅姟錛岃涓嶈瀹夎銆傚鏋滀綘鍦ㄥ畨瑁呭悗鍙堜笉鎯充嬌鐢紝璇峰垹闄?Library /StartupItems/MySQL/榪欎釜鐩綍銆?/p>
銆銆鍚姩mysql錛?/p>
銆銆2銆佸鏋滀綘宸茬粡瀹夎浜?jiǎn)MySQLStartupItem.pkg錛岄噸鏂板惎鍔ㄧ數(shù)鑴戝嵆鍙?/p>
銆銆3銆佸鏋滀綘鏈夊畨瑁匨ySQLStartupItem.pkg鎴栬呬笉鎯沖惎鍔ㄧ數(shù)鑴戯紝榪愯錛氬簲鐢ㄧ▼搴忥紞瀹炵敤紼嬪簭錛嶇粓绔▼搴忥紝鍦ㄧ粓绔腑杈撳叆鍛戒護(hù)錛?/p>
銆銆sudo /Library/StartupItems/MySQL/MySQL start
銆銆鐒跺悗杈撳叆浣犵殑緋葷粺綆＄悊鍛樺瘑鐮侊紝濡傛灉娌℃湁璁懼畾瀵嗙爜灝辯洿鎺ュ洖杞︺?/p>
銆銆鍏抽棴mysql鏈嶅姟錛?/p>
銆銆緇堢涓緭鍏ュ懡浠わ細(xì)sudo /Library/StartupItems/MySQL/MySQL stop
銆銆鐒跺悗杈撳叆浣犵殑緋葷粺綆＄悊鍛樺瘑鐮侊紝濡傛灉娌℃湁璁懼畾瀵嗙爜灝辯洿鎺ュ洖杞︺?/p>
銆銆mysql root璐︽埛瀵嗙爜錛?/p>
銆銆mysql root瀵嗙爜鍒濆鍊兼槸絀恒傝繖鏍瘋櫧鐒舵病鏈夐棶棰樸備絾寰堜笉瀹夊叏銆傚緩璁綘鏇存敼root鐢ㄦ埛瀵嗙爜銆傛敞鎰忥細(xì)mysql root鐢ㄦ埛鍜岀郴緇熶腑鐨剅oot鐢ㄦ埛鏄笉涓鏍風(fēng)殑銆傛槸瀹屽叏涓や釜涓嶅悓鐨勭敤鎴楓?/p>
銆銆鏇存敼mysql root瀵嗙爜璇峰湪緇堢涓緭鍏ュ懡浠わ細(xì)
銆銆/usr/local/mysql/bin/mysqladmin -u root password 鏂板瘑鐮?/p>
銆銆鍚屾椂浣犱篃鍙互闅忔椂浣跨敤榪欐潯鍛戒護(hù)鏇存敼浣犵殑瀵嗙爜銆?/p>
銆銆4銆佷笅杞絰鐗坢ysql鏁版嵁搴撶鐞嗗伐鍏?/p>
銆銆榪欐槸涓涓繍琛屽湪mac os
x緋葷粺涓殑mysql鏁版嵁搴撶鐞嗚蔣浠訛紝鏀寔鏈湴鍙?qiáng)杩溄E嬫暟鎹簱綆＄悊銆傚茍涓旇繕鏄厤璐圭殑銆傝繖涓▼搴忕殑浼樼偣鏄畬鍏–GI鐣岄潰銆傚茍涓斿瘑鐮佹槸淇濆瓨鍦ㄦ湰鏈轟笂鐨勩傜浉瀵規(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);
鍐嶄婦涓畝鍗曠殑渚嬪瓙
with a as (select * from test)
select * from a;
鍏跺疄灝辨槸鎶婁竴澶у爢閲嶅鐢ㄥ埌鐨凷QL璇彞鏀懼湪with as 閲岄潰錛屽彇涓涓埆鍚嶏紝鍚庨潰鐨勬煡璇㈠氨鍙互鐢ㄥ畠
榪欐牱瀵逛簬澶ф壒閲忕殑SQL璇彞璧峰埌涓涓紭鍖栫殑浣滅敤錛岃屼笖娓呮鏄庝簡(jiǎn)
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;
/*
* 璇ョ被鍙兘鍒涘緩涓涓疄渚嬶紝鍏跺畠瀵硅薄鑳藉璋冪敤鍏墮潤(rùn)鎬佹柟娉曪紙涔熺О涓虹被鏂規(guī)硶錛夎幏寰楄鍞竴瀹炰緥鐨勫紩鐢ㄣ?br />
* DBConnectionManager綾葷殑寤烘瀯鍑芥暟鏄鏈夌殑錛岃繖鏄負(fù)浜?jiǎn)閬垮厤鍏跺畠瀵硅薄鍒涘圾櫙ゾc葷殑瀹炰緥.
* DBConnectionManager綾葷殑瀹㈡埛紼嬪簭鍙互璋冪敤getInstance()鏂規(guī)硶鑾峰緱瀵硅綾誨敮涓瀹炰緥鐨勫紩鐢ㄣ?br />
* 綾葷殑鍞竴瀹炰緥鍦╣etInstance()鏂規(guī)硶絎竴嬈¤璋冪敤鏈熼棿鍒涘緩錛屾鍚庡叾寮曠敤灝變竴鐩翠繚瀛樺湪闈?rùn)鎬佸彉閲?br />
* instance涓傛瘡嬈¤皟鐢╣etInstance()閮藉鍔犱竴涓狣BConnectionManager鐨勫鎴風(fēng)▼搴忚鏁般?br />
* 鍗籌紝璇ヨ鏁頒唬琛ㄥ紩鐢―BConnectionManager鍞竴瀹炰緥鐨勫鎴風(fēng)▼搴忔繪暟錛屽畠?yōu)畣琚敤浜庢帶鍒稑q炴帴姹犵殑
* 鍏抽棴鎿嶄綔銆?璇ョ被瀹炰緥鐨勫垵濮嬪寲宸ヤ綔縐佹湁鏂規(guī)硶init()瀹屾垚銆傚叾涓?getResourceAsStream()鏂規(guī)硶
* 鐢ㄤ簬瀹氫綅騫舵墦寮澶栭儴鏂囦歡銆傚閮ㄦ枃浠剁殑瀹氫綅鏂規(guī)硶渚濊禆浜庣被瑁呰澆鍣ㄧ殑瀹炵幇銆傛爣鍑嗙殑鏈湴綾昏杞藉櫒鏌ユ壘鎿?br />
* 浣滄繪槸寮濮嬩簬綾繪枃浠舵墍鍦ㄨ礬寰勶紝涔熻兘澶熸悳绱LASSPATH涓０鏄庣殑璺緞銆俤b.properties鏄竴涓睘鎬?br />
* 鏂囦歡錛屽畠鍖呭惈瀹氫箟榪炴帴姹犵殑閿?鍊煎銆傚彲渚涘畾涔夌殑鍏敤灞炴у涓嬶細(xì)
* drivers 浠ョ┖鏍煎垎闅旂殑JDBC椹卞姩紼嬪簭綾誨垪琛?"
* logfile 鏃ュ織鏂囦歡鐨勭粷瀵硅礬寰?
* 鍏跺畠鐨勫睘鎬у拰鐗瑰畾榪炴帴姹犵浉鍏籌紝鍏跺睘鎬у悕瀛楀墠搴斿姞涓婅繛鎺ユ睜鍚嶅瓧錛?
* < poolname>.url 鏁版嵁搴撶殑 JDBC URL
* < poolname>.maxconn 鍏佽寤虹珛鐨勬渶澶ц繛鎺ユ暟錛?琛ㄧず娌℃湁闄愬埗
* < poolname>.user 鐢ㄤ簬璇ヨ繛鎺ユ睜鐨勬暟鎹簱甯愬彿
* < poolname>.password 鐩稿簲鐨勫瘑鐮?"
* 鍏朵腑url灞炴ф槸蹇呴渶鐨勶紝鑰屽叾瀹冨睘鎬у垯鏄彲閫夌殑銆傛暟鎹簱甯愬彿鍜屽瘑鐮佸繀欏誨悎娉曘傜敤浜嶹indows騫沖彴鐨?br />
* db.properties鏂囦歡紺轟緥濡備笅錛?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
* 娉ㄦ剰鍦╓indows璺緞涓殑鍙嶆枩鏉犲繀欏昏緭鍏?涓紝榪欐槸鐢變簬灞炴ф枃浠朵腑鐨勫弽鏂滄潬鍚屾椂涔熸槸涓涓漿涔夊瓧絎︺?br />
* init()鏂規(guī)硶鍦ㄥ垱寤哄睘鎬у璞″茍璇誨彇db.properties鏂囦歡涔嬪悗錛屽氨寮濮嬫鏌ogfile灞炴с傚鏋滃睘
* 鎬ф枃浠朵腑娌℃湁鎸囧畾鏃ュ織鏂囦歡錛屽垯榛樿涓哄綋鍓嶇洰褰曚笅鐨凞BConnectionManager.log鏂囦歡銆傚鏃ュ織鏂?br />
* 浠舵棤娉曚嬌鐢紝鍒欏悜System.err杈撳嚭鏃ュ織璁板綍銆傝杞藉拰娉ㄥ唽鎵鏈夊湪drivers灞炴т腑鎸囧畾鐨凧DBC椹卞姩
* 紼嬪簭loadDrivers()鏂規(guī)硶瀹炵幇銆傝鏂規(guī)硶鍏堢敤StringTokenizer灝哾rivers灞炴у煎垎鍓蹭負(fù)瀵瑰簲浜庨┍
* 鍔ㄧ▼搴忓悕縐扮殑瀛楃涓詫紝鐒跺悗渚濇瑁呰澆榪欎簺綾誨茍鍒涘緩鍏跺疄渚嬶紝鏈鍚庡湪DriverManager涓敞鍐岃瀹炰緥騫舵妸
* 瀹冨姞鍏ュ埌涓涓鏈夌殑鍚戦噺drivers銆傚悜閲廳rivers灝嗙敤浜庡叧闂湇鍔℃椂浠嶥riverManager鍙栨秷鎵鏈?br />
* JDBC 椹卞姩紼嬪簭鐨勬敞鍐屻俰nit()鏂規(guī)硶鐨勬渶鍚庝竴涓換鍔℃槸璋冪敤縐佹湁鏂規(guī)硶createPools()鍒涘緩榪炴帴姹犲
* 璞°俢reatePools()鏂規(guī)硶鍏堝垱寤烘墍鏈夊睘鎬у悕瀛楃殑鏋氫婦瀵硅薄錛堝嵆Enumeration瀵硅薄錛岃瀵硅薄鍙互鎯寵薄
* 涓轟竴涓厓绱犵郴鍒楋紝閫愭璋冪敤鍏秐extElement()鏂規(guī)硶灝嗛『搴忚繑鍥炲悇鍏冪礌錛夛紝鐒跺悗鍦ㄥ叾涓悳绱㈠悕瀛椾互“.url”
* 緇撳熬鐨勫睘鎬с傚浜庢瘡涓涓鍚堟潯浠剁殑灞炴э紝鍏堟彁鍙栧叾榪炴帴姹犲悕瀛楅儴鍒嗭紝榪涜岃鍙栨墍鏈夊睘浜庤榪炴帴姹犵殑灞炴э紝
* 鏈鍚庡垱寤鴻繛鎺ユ睜瀵硅薄騫舵妸瀹冧繚瀛樺湪瀹炰緥鍙橀噺pools涓傛暎鍒楄〃錛圚ashtable綾?錛塸ools瀹炵幇榪炴帴姹犲悕瀛?br />
* 鍒拌繛鎺ユ睜瀵硅薄涔嬮棿鐨勬槧灝勶紝姝ゅ浠ヨ繛鎺ユ睜鍚嶅瓧涓洪敭錛岃繛鎺ユ睜瀵硅薄涓哄箋?涓轟究浜庡鎴風(fēng)▼搴忎粠鎸囧畾榪炴帴姹犺幏
* 寰楀彲鐢ㄨ繛鎺ユ垨灝嗚繛鎺ヨ繑鍥炵粰榪炴帴姹狅紝綾籇BConnectionManager鎻愪緵浜?jiǎn)鏂规硶getConnection()鍜?br />
* freeConnection()銆傛墍鏈夎繖浜涙柟娉曢兘瑕佹眰鍦ㄥ弬鏁頒腑鎸囧畾榪炴帴姹犲悕瀛楋紝鍏蜂綋鐨勮繛鎺ヨ幏鍙栨垨榪斿洖鎿嶄綔鍒欒皟
* 鐢ㄥ搴旂殑榪炴帴姹犲璞″畬鎴愩備負(fù)瀹炵幇榪炴帴姹犵殑瀹夊叏鍏抽棴錛孌BConnectionManager鎻愪緵浜?jiǎn)鏂规硶r(shí)elease()銆?br />
* 鍦ㄤ笂闈㈡垜浠凡緇忔彁鍒幫紝鎵鏈塂BConnectionManager鐨勫鎴風(fēng)▼搴忛兘搴旇璋冪敤闈?rùn)鎬佹柟娉昰etInstance()
* 浠ヨ幏寰楄綆＄悊鍣ㄧ殑寮曠敤錛屾璋冪敤灝嗗鍔犲鎴風(fēng)▼搴忚鏁般傚鎴風(fēng)▼搴忓湪鍏抽棴鏃惰皟鐢╮elease()鍙互閫掑噺璇ヨ鏁般?br />
* 褰撴渶鍚庝竴涓鎴風(fēng)▼搴忚皟鐢╮elease()錛岄掑噺鍚庣殑寮曠敤璁℃暟涓?錛屽氨鍙互璋冪敤鍚勪釜榪炴帴姹犵殑release()鏂規(guī)硶
* 鍏抽棴鎵鏈夎繛鎺ヤ簡(jiǎn)銆傜鐞嗙被release()鏂規(guī)硶鏈鍚庣殑浠誨姟鏄挙閿鎵鏈塉DBC椹卞姩紼嬪簭鐨勬敞鍐屻?br />
*/
/**
* 綆＄悊綾籇BConnectionManager鏀寔瀵逛竴涓垨澶氫釜鐢卞睘鎬ф枃浠跺畾涔夌殑鏁版嵁搴撹繛鎺?br />
* 姹犵殑璁塊棶.瀹㈡埛紼嬪簭鍙互璋冪敤getInstance()鏂規(guī)硶璁塊棶鏈被鐨勫敮涓瀹炰緥.
*/
public class DBConnectionManager {
static private DBConnectionManager instance; // 鍞竴瀹炰緥
static private int clients;
private Vector drivers = new Vector();
private PrintWriter log;
private Hashtable pools = new Hashtable();
/**
* 榪斿洖鍞竴瀹炰緥.濡傛灉鏄涓嬈¤皟鐢ㄦ鏂規(guī)硶,鍒欏垱寤哄疄渚?br />
* @return DBConnectionManager 鍞竴瀹炰緥
*/
static synchronized public DBConnectionManager getInstance() {
if (instance == null) {
instance = new DBConnectionManager();
}
clients++;
return instance;
}
/**
* 寤烘瀯鍑芥暟縐佹湁浠ラ槻姝㈠叾瀹冨璞″垱寤烘湰綾誨疄渚?br />
*/
private DBConnectionManager() {
init();
}
/**
* * 灝嗚繛鎺ュ璞¤繑鍥炵粰鐢卞悕瀛楁寚瀹氱殑榪炴帴姹?br />
* @param name鍦ㄥ睘鎬ф枃浠朵腑瀹氫箟鐨勮繛鎺ユ睜鍚嶅瓧
* @param con榪炴帴瀵硅薄""""r
*/
public void freeConnection(String name, Connection con) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
pool.freeConnection(con);
}
}
/**
* 鑾峰緱涓涓彲鐢ㄧ殑(絀洪棽鐨?榪炴帴.濡傛灉娌℃湁鍙敤榪炴帴,涓斿凡鏈夎繛鎺ユ暟灝忎簬鏈澶ц繛鎺ユ暟 053 * 闄愬埗,鍒欏垱寤哄茍榪斿洖鏂拌繛
* @param name鍦ㄥ睘鎬ф枃浠朵腑瀹氫箟鐨勮繛鎺ユ睜鍚嶅瓧 056 *
* @return Connection 鍙敤榪炴帴鎴杗ull 057
*/
public Connection getConnection(String name) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
return pool.getConnection();
}
return null;
}
/**
* 鑾峰緱涓涓彲鐢ㄨ繛鎺?鑻ユ病鏈夊彲鐢ㄨ繛鎺?涓斿凡鏈夎繛鎺ユ暟灝忎簬鏈澶ц繛鎺ユ暟闄愬埗,
* 鍒欏垱寤哄茍榪斿洖鏂拌繛鎺?鍚﹀垯,鍦ㄦ寚瀹氱殑鏃墮棿鍐呯瓑寰呭叾瀹冪嚎紼嬮噴鏀捐繛鎺?
* @param name 榪炴帴姹犲悕瀛?071 *
* @param time浠ユ縐掕鐨勭瓑寰呮椂闂?a>""""r
* @return Connection 鍙敤榪炴帴鎴杗ull
*/
public Connection getConnection(String name, long time) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
return pool.getConnection(time);
}
return null;
}
/**
* 鍏抽棴鎵鏈夎繛鎺?鎾ら攢椹卞姩紼嬪簭鐨勬敞鍐?a>""""r
*/
public synchronized void release() {
// 絳夊緟鐩村埌鏈鍚庝竴涓鎴風(fēng)▼搴忚皟鐢?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椹卞姩紼嬪簭 " + driver.getClass().getName() + "鐨勬敞鍐?);
} catch (SQLException e) {
log(e, "鏃犳硶鎾ら攢涓嬪垪JDBC椹卞姩紼嬪簭鐨勬敞鍐? " + driver.getClass().getName());
}
}
}
/**
* 鏍規(guī)嵁鎸囧畾灞炴у垱寤鴻繛鎺ユ睜瀹炰緥.
* @param props 榪炴帴姹犲睘鎬?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 + " .榪炴帴姹? " + poolName);
max = 0;
}
DBConnectionPool pool = new DBConnectionPool(poolName, url,
user, password, max);
pools.put(poolName, pool);
log("鎴愬姛鍒涘緩榪炴帴姹? + poolName);
}
}
}
/**
* 璇誨彇灞炴у畬鎴愬垵濮嬪寲
*/
private void init() {
InputStream is = getClass().getResourceAsStream("/db.properties");
Properties dbProps = new Properties();
try {
dbProps.load(is);
} catch (Exception e) {
System.err.println("涓嶈兘璇誨彇灞炴ф枃浠? "+"璇風(fēng)‘淇漝b.properties鍦–LASSPATH鎸囧畾鐨勮礬寰勪腑");
return;
}
String logFile = dbProps.getProperty("logfile","DBConnectionManager.log");
try {
log = new PrintWriter(new FileWriter(logFile, true), true);
} catch (IOException e) {
System.err.println("鏃犳硶鎵撳紑鏃ュ織鏂囦歡: " + logFile);
log = new PrintWriter(System.err);
}
loadDrivers(dbProps);
createPools(dbProps);
}
/**
* 瑁呰澆鍜屾敞鍐屾墍鏈塉DBC椹卞姩紼嬪簭
* @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椹卞姩紼嬪簭" + driverClassName);
} catch (Exception e) {
e.printStackTrace();
log("鏃犳硶娉ㄥ唽JDBC椹卞姩紼嬪簭: " + driverClassName + ", 閿欒: " + e);
}
}
}
/**
* 灝嗘枃鏈俊鎭啓鍏ユ棩蹇楁枃浠?br />
*/
private void log(String msg) {
log.println(new Date() + ": " + msg);
}
/**
* 灝嗘枃鏈俊鎭笌寮傚父鍐欏叆鏃ュ織鏂囦歡
*/
private void log(Throwable e, String msg) {
log.println(new Date() + ": " + msg);
e.printStackTrace(log);
}
// ///////////////////////////////////////////////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* DBConnectionPool瀹炵幇錛屽畠琛ㄧず鎸囧悜鏌愪釜鏁版嵁搴撶殑榪炴帴姹犮傛暟鎹簱鐢盝DBC URL鏍囪瘑銆備竴涓狫DBCURL鐢變笁閮ㄥ垎緇勬垚錛氬崗璁爣璇嗭紙鎬繪槸jdbc錛夛紝
* 椹卞姩紼嬪簭鏍囪瘑錛堝odbc銆乮db銆乷racle絳夛級(jí)錛屾暟鎹簱鏍囪瘑錛堝叾鏍煎紡渚濊禆浜庨┍鍔ㄧ▼搴忥級(jí)銆備緥濡傦紝jdbc:odbc:demo錛屽嵆鏄竴涓寚鍚慸emo鏁版嵁
* 搴撶殑JDBCURL錛岃屼笖璁塊棶璇ユ暟鎹簱瑕佷嬌鐢↗DBC-ODBC椹卞姩紼嬪簭銆傛瘡涓繛鎺ユ睜閮芥湁涓涓緵瀹㈡埛紼嬪簭浣跨敤鐨勫悕瀛椾互鍙?qiáng)鍙夌殑鐢ㄦ埛甯愬彿銆佸瘑鐮併佹渶
* 澶ц繛鎺ユ暟闄愬埗銆傚鏋淲eb搴旂敤紼嬪簭鎵鏀寔鐨勬煇浜涙暟鎹簱鎿嶄綔鍙互琚墍鏈夌敤鎴鋒墽琛岋紝鑰屽叾瀹冧竴浜涙搷浣滃簲鐢辯壒鍒鍙殑鐢ㄦ埛鎵ц錛屽垯鍙互涓轟袱綾繪搷浣?br />
* 鍒嗗埆瀹氫箟榪炴帴姹狅紝涓や釜榪炴帴姹犱嬌鐢ㄧ浉鍚岀殑JDBC URL錛屼絾浣跨敤涓嶅悓鐨勫笎鍙峰拰瀵嗙爜銆傜被DBConnectionPool鐨勫緩鏋勫嚱鏁伴渶瑕佷笂榪版墍鏈夋暟鎹綔涓哄叾
* 鍙傛暟銆傚鎴風(fēng)▼搴忓彲浠ヤ嬌鐢―BConnectionPool
* 綾繪彁渚涚殑涓や釜鏂規(guī)硶鑾峰彇鍙敤榪炴帴銆備袱鑰呯殑鍏卞悓涔嬪鍦ㄤ簬錛氬榪炴帴姹犱腑瀛樺湪鍙敤榪炴帴錛屽垯鐩存帴榪斿洖錛屽惁鍒欏垱寤烘柊鐨勮繛鎺ュ茍榪斿洖銆傚鏋滄病鏈夊彲鐢ㄨ繛鎺?br />
* 涓斿凡鏈夎繛鎺ユ繪暟絳変簬鏈澶ч檺鍒舵暟錛岀涓涓柟娉曞皢鐩存帴榪斿洖null錛岃岀浜屼釜鏂規(guī)硶灝嗙瓑寰呯洿鍒版湁鍙敤榪炴帴涓烘銆傛墍鏈夌殑鍙敤榪炴帴瀵硅薄鍧囩櫥璁板湪鍚嶄負(fù)
* freeConnections鐨勫悜閲忥紙Vector錛変腑銆傚鏋滃悜閲忎腑鏈夊浜庝竴涓殑榪炴帴錛実etConnection()鎬繪槸閫夊彇絎竴涓傚悓鏃訛紝鐢變簬鏂扮殑鍙敤榪炴帴鎬?br />
* 鏄粠灝鵑儴鍔犲叆鍚戦噺錛屼粠鑰屼嬌寰楁暟鎹簱榪炴帴鐢變簬闀挎椂闂撮棽緗岃鍏抽棴鐨勯闄╁噺浣庡埌鏈灝忕▼搴︺?絎竴涓猤etConnection()鍦ㄨ繑鍥炲彲鐢ㄨ繛鎺ョ粰瀹㈡埛
* 紼嬪簭涔嬪墠錛岃皟鐢ㄤ簡(jiǎn)isClosed()鏂規(guī)硶楠岃瘉榪炴帴浠嶆棫鏈夋晥銆傚鏋滆榪炴帴琚叧闂垨瑙﹀彂寮傚父錛実etConnection()閫掑綊鍦拌皟鐢ㄨ嚜宸變互灝濊瘯鑾峰彇鍙﹀鐨?br />
* 鍙敤榪炴帴銆傚鏋滃湪鍚戦噺freeConnections涓笉瀛樺湪浠諱綍鍙敤榪炴帴錛実etConnection()鏂規(guī)硶媯(gè)鏌ユ槸鍚﹀凡緇忔寚瀹氭渶澶ц繛鎺ユ暟闄愬埗銆傚宸茬粡鎸囧畾錛?br />
* 鍒欐鏌ュ綋鍓嶈繛鎺ユ暟鏄惁宸茬粡鍒拌揪鏋侀檺銆傛澶刴axConn涓?琛ㄧず娌℃湁闄愬埗銆傚鏋滄病鏈夋寚瀹氭渶澶ц繛鎺ユ暟闄愬埗鎴栧綋鍓嶈繛鎺ユ暟灝忎簬璇ュ鹼紝璇ユ柟娉曞皾璇曞垱寤?br />
* 鏂扮殑榪炴帴銆傚鍒涘緩鎴愬姛錛屽垯澧炲姞宸蹭嬌鐢ㄨ繛鎺ョ殑璁℃暟騫惰繑鍥烇紝鍚﹀垯榪斿洖絀哄箋傚垱寤烘柊榪炴帴鐢眓ewConnection()鏂規(guī)硶瀹炵幇銆?br />
* 鍒涘緩榪囩▼涓庢槸鍚﹀凡緇忔寚瀹氭暟鎹簱甯愬彿銆佸瘑鐮佹湁鍏熾侸DBC鐨凞riverManager綾繪彁渚涘涓猤etConnection()鏂規(guī)硶錛岃繖浜涙柟娉曡鐢ㄥ埌JDBC URL
* 涓庡叾瀹冧竴浜涘弬鏁幫紝濡傜敤鎴峰笎鍙峰拰瀵嗙爜絳夈侱riverManager灝嗕嬌鐢ㄦ寚瀹氱殑JDBC URL紜畾閫傚悎浜庣洰鏍囨暟鎹簱鐨勯┍鍔ㄧ▼搴忓強(qiáng)寤虹珛榪炴帴銆?br />
* 絎簩涓猤etConnection()鏂規(guī)硶闇瑕佷竴涓互姣涓哄崟浣嶇殑鏃墮棿鍙傛暟錛岃鍙傛暟琛ㄧず瀹㈡埛紼嬪簭鑳藉絳夊緟鐨勬渶闀挎椂闂淬傚緩绔嬭繛鎺ョ殑鍏蜂綋鎿?br />
* 浣滀粛鏃х敱絎竴涓猤etConnection()鏂規(guī)硶瀹炵幇銆傝鏂規(guī)硶鎵ц鏃跺厛灝唖tartTime鍒濆鍖栦負(fù)褰撳墠鏃墮棿銆傚湪while寰幆涓皾璇曡幏寰椾竴涓繛鎺ャ傚鏋滃け
* 璐ワ紝鍒欎互緇欏畾鐨勬椂闂村間負(fù)鍙傛暟璋冪敤wait()銆倃ait()鐨勮繑鍥炲彲鑳芥槸鐢變簬鍏跺畠綰跨▼璋冪敤notify()鎴杗otifyAll()錛屼篃鍙兘鏄敱浜庨瀹氭椂闂村凡鍒般?br />
* 涓烘壘鍑簑ait()榪斿洖鐨勭湡姝ｅ師鍥狅紝紼嬪簭鐢ㄥ綋鍓嶆椂闂村噺寮濮嬫椂闂達(dá)紙startTime錛夛紝濡傚樊鍊煎ぇ浜庨瀹氭椂闂村垯榪斿洖絀哄鹼紝鍚﹀垯鍐嶆璋冪敤getConnection()銆?br />
* 鎶婄┖闂茬殑榪炴帴鐧昏鍒拌繛鎺ユ睜鐢眆reeConnection()鏂規(guī)硶瀹炵幇錛屽畠鐨勫弬鏁頒負(fù)榪斿洖緇欒繛鎺ユ睜鐨勮繛鎺ュ璞°傝瀵硅薄琚姞鍏ュ埌freeConnections
* 鍚戦噺鐨勬湯灝撅紝鐒跺悗鍑忓皯宸蹭嬌鐢ㄨ繛鎺ヨ鏁般傝皟鐢╪otifyAll()鏄負(fù)浜?jiǎn)閫氱煡鍏跺畠姝ｅ湪絳夊緟鍙敤榪炴帴鐨勭嚎紼嬨?璁稿Servlet寮曟搸涓哄疄鐜板畨鍏ㄥ叧闂彁渚?br />
* 澶氱鏂規(guī)硶銆傛暟鎹簱榪炴帴姹犻渶瑕佺煡閬撹浜嬩歡浠ヤ繚璇佹墍鏈夎繛鎺ヨ兘澶熸甯稿叧闂侱BConnectionManager綾昏礋鍗忚皟鏁翠釜鍏抽棴榪囩▼錛屼絾鍏抽棴榪炴帴姹犱腑鎵鏈夎繛
* 鎺ョ殑浠誨姟鍒欑敱DBConnectionPool綾昏礋璐ｃ俽elease()鏂規(guī)硶渚汥BConnectionManager璋冪敤銆傝鏂規(guī)硶閬嶅巻freeConnections鍚戦噺騫跺叧闂墍鏈夎繛鎺ワ紝
* 鐒跺悗浠庡悜閲忎腑鍒犻櫎榪欎簺榪炴帴銆?br />
*/
/**
* 姝ゅ唴閮ㄧ被瀹氫箟浜?jiǎn)涓涓繛鎺ユ睜.瀹冭兘澶熸牴鎹姹傚垱寤烘柊榪炴帴,鐩村埌棰勫畾鐨勬渶""""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;
/**
* 鍒涘緩鏂扮殑榪炴帴姹?br />
* @param name榪炴帴姹犲悕瀛?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;
}
/**
* 灝嗕笉鍐嶄嬌鐢ㄧ殑榪炴帴榪斿洖緇欒繛鎺ユ睜
* @param con瀹㈡埛紼嬪簭閲婃斁鐨勮繛鎺?br />
*/
public synchronized void freeConnection(Connection con) {
// 灝嗘寚瀹氳繛鎺ュ姞鍏ュ埌鍚戦噺鏈熬
freeConnections.addElement(con);
checkedOut--;
notifyAll();
}
/**
* 浠庤繛鎺ユ睜鑾峰緱涓涓彲鐢ㄨ繛鎺?濡傛病鏈夌┖闂茬殑榪炴帴涓斿綋鍓嶈繛鎺ユ暟灝忎簬鏈澶ц繛鎺?鏁伴檺鍒?鍒欏垱寤烘柊榪炴帴.
* 濡傚師鏉ョ櫥璁頒負(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 + "鍒犻櫎涓涓棤鏁堣繛鎺?);
// 閫掑綊璋冪敤鑷繁,灝濊瘯鍐嶆鑾峰彇鍙敤榪炴帴
con = getConnection();
}
} catch (SQLException e) {
log("浠庤繛鎺ユ睜" + name + "鍒犻櫎涓涓棤鏁堣繛鎺?);
// 閫掑綊璋冪敤鑷繁,灝濊瘯鍐嶆鑾峰彇鍙敤榪炴帴
con = getConnection();
}
} else if (maxConn == 0 || checkedOut < maxConn) {
con = newConnection();
}
if (con != null) {
checkedOut++;
}
return con;
}
/**
* 浠庤繛鎺ユ睜鑾峰彇鍙敤榪炴帴.鍙互鎸囧畾瀹㈡埛紼嬪簭鑳藉絳夊緟鐨勬渶闀挎椂闂?鍙傝鍓嶄竴涓猤etConnection()鏂規(guī)硶.
* @param timeout浠ユ縐掕鐨勭瓑寰呮椂闂撮檺鍒?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()榪斿洖鐨勫師鍥犳槸瓚呮椂
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("鍏抽棴榪炴帴姹? + name + "涓殑涓涓繛鎺?);
} catch (SQLException e) {
log(e, "鏃犳硶鍏抽棴榪炴帴姹? + name + "涓殑榪炴帴");
e.printStackTrace();
}
}
freeConnections.removeAllElements();
}
/**
* 鍒涘緩鏂扮殑榪炴帴
*/
private Connection newConnection() {
Connection con = null;
try {
if (user==null||"".equals(user)) {
con = DriverManager.getConnection(URL);
} else {
con = DriverManager.getConnection(URL, user, password);
}
log("榪炴帴姹? + name + "鍒涘緩涓涓柊鐨勮繛鎺?);
} catch (SQLException e) {
log(e, "鏃犳硶鍒涘緩涓嬪垪URL鐨勮繛鎺? " + URL);
return null;
}
return con;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
}
鍦╯qlserver2000錛宼omcat5.5楠岃瘉閫氳繃
鏂規(guī)硶璋冪敤錛?/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; --> “榪愯”涓緭鍏?regedit錛屽紑鍚敞鍐岃〃緙栬緫鍣ㄣ?br />
瀹氫綅鍒?br /> [HKEY_LOCAL_MACHINE"SOFTWARE"Microsoft"Windows NT"CurrentVersion"Perflib
澶勶紝鍦ㄥ彸杈圭殑鏍?wèi)迮炵洰褰曚笅鍙互鐪嬪埌Perflib鐩綍涓嬫湁004鍜?09涓や釜瀛愮洰褰曘?br />
鍦⊿ql Server 2005 鐨勫畨瑁呭府鍔╂枃浠朵腑璇寸殑鏄渶瑕佹煡鐪?09鐩綍鐨勬敞鍐岃〃欏癸紝鑰屾垜浠ぇ閮ㄥ垎浜轟嬌鐢ㄧ殑鏄畝浣撲腑鏂囩殑鎿嶄綔緋葷粺錛屾墍浠ヤ笉鑳芥寜甯姪涓鐨勶紝鑰屾槸闇瑕佹敞鎰?04鐩綍涓殑鍐呭銆?br />
鎵撳紑004 鐩綍涓殑鍐呭錛屽彲浠ョ湅鍒板涓嬪浘錛?br />
鎴戜滑鍒嗗埆鍙屽嚮 “Counter” 欏?鍜?“Help” 欏癸紝瀵熺湅鍏朵腑鐨勬渶鍚庣殑鏁板瓧錛屽涓嬪浘錛?br />
Counter 欏圭殑鍐呭錛?br />
Helper 欏瑰唴瀹?br />
榪欐椂鍊欙紝鎴戜滑鐭ラ亾錛孋ounter 欏圭殑鏁板瓧鏄?556錛孒elper欏圭殑鍐呭鏄?557銆?br />
鐒跺悗錛屾搷浣滄敞鍐岃〃緙栬緫鍣ㄧ殑宸﹁竟鐨勭洰褰曟爲(wèi)錛屽畾浣嶅埌Perflib鐩綍涓嬶紝騫舵敞鎰忔鏌ュ彸杈圭獥鍙ｇ殑 “Laster Counter”欏瑰拰“Laster Help”欏圭殑鍊鹼紝騫舵妸Laster Counter鐨勫兼敼鎴愬垰鎵嶈褰曚笅鐨凜ounter鍊?556錛屾妸Laster Help 鐨勫兼敼鎴愬垰鎵嶈涓嬬殑 Help鐨勫?557銆?br />
瑕佹敞鎰忕殑鏄紝淇敼鏁板瓧鐨勬椂鍊欙紝杈撳叆鐨勬椂鍊欏繀欏婚夊垯鍩烘暟鏄?“鍗佽繘鍒?#8221;錛屽惁鍒欐暟瀛楀皢涓嶅尮閰嶏紝Sql Server 2005 媯(gè)鏌ュ皢鍐嶆澶辮觸銆?br />
鐒跺悗鍏抽棴娉ㄥ唽琛ㄧ紪杈戝櫒錛屽紑濮嬪畨瑁?Sql Server 2005 錛岀粷瀵瑰彲浠ュ畨瑁呮垚鍔熴?
]]>
1>灝唌ysql瀹夎鏂囦歡(鏈漢浣跨敤mysql5.0.51a-linux-i686-glibc23.tar.gz)瑙ｅ帇鍒板搴旂洰褰曪紝鍦ㄦ涓?/home/seal/mysql
2>榪涘叆婧愮爜鐩綍緙栬瘧瀹夎
CODE:
#cd /home/seal/mysql
#./configure --prefix=/usr/local/mysql --with-charset=gbk |娉?閰嶇疆Mysql瀹夎璺緞騫朵笖鏀寔涓枃
#make |娉?緙栬瘧
#make install |娉?緙栬瘧瀹夎
3>鏇挎崲/etc/my.cnf鏂囦歡,榪涘叆婧愮爜鍖?鎵ц鍛戒護(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>瀹屾垚浠ヤ笂鎿嶄綔浠ュ悗榪涜鍒濆鍖栨暟鎹簱,榪涘叆宸茬粡瀹夎濂界殑mysql鐩綍
CODE:
#cd /usr/local/mysql
#bin/mysql_install_db --user=mysql |娉?--user=mysql 鍒濆鍖栬〃騫朵笖瑙勫畾鐢╩ysql鐢ㄦ埛
6>璁劇疆緇檓ysql鍜宺oot鐢ㄦ埛璁懼畾璁塊棶鏉冮檺 鎴戜滑鍏堣繘鍏ysql鐩綍
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 |娉?璁懼畾mysql緇勮兘澶熻闂?usr/local/mysq
7>鍚姩mysql,榪涘叆宸茬粡瀹夎濂界殑鐩綍
CODE:
#cd /usr/local/mysql
#bin/mysqld_safe --user=mysql &
8>
淇敼mysql鏁版嵁搴撹秴綰х敤鎴穜oot鐨勭己鐪佸瘑鐮?
/usr/local/mysql/bin/mysqladmin -u root password 'mysql'
鍏抽棴mysql鏈嶅姟鍣?
cd /usr/local/mysql/bin
./mysqladmin -u root -p shutdown
9>璁懼畾寮鏈哄氨鍚姩mysql,榪涘叆婧愮爜鐩綍涓?/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>璁劇疆Mysql榪滅▼璁塊棶錛?br /> 鍦ㄥ惎鍔╩ysql鍚庯細(xì)
mysql>GRANT ALL PRIVILEGES ON *.* TO ‘myuser’@'%’ IDENTIFIED BY ‘mypassword’ WI
TH GRANT OPTION;
mysql>Flush Privileges;
瀹夎瀹屾瘯銆?br />
]]>
瑙ｅ喅鏂規(guī)硶錛?/span>
1銆?/span>鏀硅〃娉曘傚彲鑳芥槸浣犵殑甯愬彿涓嶅厑璁鎬粠榪滅▼鐧婚檰錛屽彧鑳藉湪localhost銆傝繖涓椂鍊欏彧瑕佸湪localhost鐨勯偅鍙扮數(shù)鑴戯紝鐧誨叆mysql鍚庯紝鏇存敼 “mysql” 鏁版嵁搴撻噷鐨?/span> “user” 琛ㄩ噷鐨?/span> “host” 欏癸紝浠?/span>“localhost”鏀圭О“%”
|
mysql -u root -pvmwaremysql>use mysql; |
2. 鎺堟潈娉曘備緥濡傦紝浣犳兂myuser浣跨敤mypassword浠庝換浣曚富鏈鴻繛鎺ュ埌mysql鏈嶅姟鍣ㄧ殑璇濄?/span>
|
GRANT ALL PRIVILEGES ON *.* TO ‘myuser’@'%’ IDENTIFIED BY ‘mypassword’ WI |
濡傛灉浣犳兂鍏佽鐢ㄦ埛myuser浠?/span>ip涓?/span>192.168.1.6鐨勪富鏈鴻繛鎺ュ埌mysql鏈嶅姟鍣紝騫朵嬌鐢?/span>mypassword浣滀負(fù)瀵嗙爜
|
GRANT ALL PRIVILEGES ON *.* TO ‘myuser’@'192.168.1.3′ IDENTIFIED BY |
浣夸慨鏀圭敓鏁?/span>.灝卞彲浠ヤ簡(jiǎn)
]]>
緇忚繃鍑犲皬鏃剁殑鎸?zhuān)鎵庡Q屽湪閰嶇疆綆＄悊鍣ㄩ噷闈㈠彂鐜頒簡(jiǎn)闂錛屽師鏉ユ槸TCPIP鏈嶅姟娌℃湁榛樿鎵撳紑錛岃В鍐沖涓嬶細(xì)
1銆佹墦寮SQL Server Configuration Manager -> Protocols for SQLEXPRESS -> TCP/IP
2銆佸彸閿崟鍑誨惎鍔═CP/IP
3銆佸弻鍑昏繘鍏ュ睘鎬э紝鎶奍P鍦板潃涓殑IP all涓殑TCP绔彛璁劇疆涓?433
4銆侀噸鏂板惎鍔⊿QL 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.
鎵浠ュ湪鍒犻櫎姝ゅ瓧孌墊椂闇瑕佸厛灝嗙郴緇熻〃涓殑瀵瑰簲榛樿綰︽潫鍒犻櫎錛?鍙互浣跨敤涓嬮潰鐨勮剼鏈繘琛屽垹闄わ細(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)
鍦ㄥ垹闄ゅ搴旂殑榛樿綰︽潫鍚庯紝鎵ц錛?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琛ㄤ腑鏈変笁涓瓧孌?id鍞竴涓斾負(fù)涓婚敭,鑷姩澧為暱; PositionName,EnglishPositionName涓湁閲嶅鐨勮褰?姣斿:
id PositionName EnglishPositionName
20 鍏朵粬 Others
21 璐ㄩ噺宸ョ▼甯?nbsp; QC Engineer
22 鍏朵粬 Others
.......
100 璐ㄩ噺宸ョ▼甯?nbsp; QC Engineer
闇瑕佸墧闄ら噸澶嶇殑"鍏朵粬","璐ㄩ噺宸ョ▼甯?絳夎褰曘?/p>
閲囩敤鐨凷QL璇彞錛?br />
Delete from TempA where id not in (
select max(t1.id) from TempA t1 group by
t1.PositionName,t1.EnglishPositionName)
璇存槑錛?br />
(1)闇瑕佸墧闄ら偅鍑犱釜鐢ㄤ簬鍒ゆ柇閲嶅鐨勫瓧孌碉紝鍒欏皢瀹冧滑鏀懼湪group by璇彞涔嬪悗銆?br />
(2)max(t1.id) 涔熷彲浠ユ敼鎴愶細(xì)min(t1.id)
]]>