提交 f4871d9f authored 作者: Thomas Mueller's avatar Thomas Mueller

--no commit message

--no commit message
上级 7de9aac9
...@@ -11,7 +11,6 @@ import java.io.InputStreamReader; ...@@ -11,7 +11,6 @@ import java.io.InputStreamReader;
import java.io.OutputStreamWriter; import java.io.OutputStreamWriter;
import java.io.RandomAccessFile; import java.io.RandomAccessFile;
import org.h2.server.web.PageParser;
import org.h2.tools.indexer.HtmlConverter; import org.h2.tools.indexer.HtmlConverter;
import org.h2.util.IOUtils; import org.h2.util.IOUtils;
import org.h2.util.StringUtils; import org.h2.util.StringUtils;
...@@ -49,15 +48,4 @@ public class PropertiesToUTF8 { ...@@ -49,15 +48,4 @@ public class PropertiesToUTF8 {
} }
} }
private static String unescapeHtml(String s) {
String codes = "&lt; < &amp; & &gt; > &Auml; \u00c4 &Ouml; \u00d6 &Uuml; \u00dc &auml; \u00e4 &ouml; \u00f6 &uuml; \u00fc &ntilde; \u00f1 &oacute; \u00f3 &Iacute; \u00cd &ccedil; \u00e7 &eagrave; \u00e8 &ecirc; \u00ea &Uacute; \u00da &aacute; \u00e1 &uacute; \u00fa &eacute; \u00e9 &egrave; \u00e8 &icirc; \u00ee";
String[] list = StringUtils.arraySplit(codes, ' ', false);
for(int i=0; i<list.length; i+=2) {
s = StringUtils.replaceAll(s, list[i], list[i+1]);
}
if(s.indexOf("&") >= 0) {
throw new Error("??? " + s);
}
return s;
}
} }
/*
* Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html).
* Initial Developer: H2 Group
*/
package org.h2.tools.doc; package org.h2.tools.doc;
import java.io.File; import java.io.File;
...@@ -21,8 +25,12 @@ public class SpellChecker { ...@@ -21,8 +25,12 @@ public class SpellChecker {
private boolean debug; private boolean debug;
private boolean printDictionary; private boolean printDictionary;
private boolean addToDictionary; private boolean addToDictionary;
private static final String[] SUFFIX = new String[]{"java", "sql", "cpp", "txt", "html", "xml", "jsp", "css", "bat", "nsi", "csv", "xml", "js", "def", "dev", "h", "Driver", "properties", "win", "task", "php", "" }; private static final String[] SUFFIX = new String[]{
private static final String[] IGNORE = new String[]{"gif", "png", "odg", "ico", "sxd", "zip", "bz2", "rc", "layout", "res", "dll", "jar"}; "html", "java", "sql", "txt", "xml", "jsp", "css", "bat", "csv", "xml", "js", "Driver", "properties", "task", "php", "" };
private static final String[] IGNORE = new String[]{
"cpp", "h", "win", "dev", "def", "nsi",
"gif", "png", "odg", "ico", "sxd", "zip", "bz2", "rc", "layout", "res", "dll", "jar"};
private static final String PREFIX_IGNORE = "abc";
public static void main(String[] args) throws IOException { public static void main(String[] args) throws IOException {
String dir = "src"; String dir = "src";
...@@ -57,11 +65,10 @@ public class SpellChecker { ...@@ -57,11 +65,10 @@ public class SpellChecker {
System.out.println("UNKNOWN WORDS"); System.out.println("UNKNOWN WORDS");
for(Iterator it = unknown.keySet().iterator(); it.hasNext();) { for(Iterator it = unknown.keySet().iterator(); it.hasNext();) {
String s = (String) it.next(); String s = (String) it.next();
int count = ((Integer) unknown.get(s)).intValue(); // int count = ((Integer) unknown.get(s)).intValue();
if(count > 5) {
System.out.print(s + " "); System.out.print(s + " ");
} }
} System.out.println();
System.out.println(); System.out.println();
throw new IOException("spell check failed"); throw new IOException("spell check failed");
} }
...@@ -69,15 +76,9 @@ public class SpellChecker { ...@@ -69,15 +76,9 @@ public class SpellChecker {
private void process(File file) throws IOException { private void process(File file) throws IOException {
String name = file.getCanonicalPath(); String name = file.getCanonicalPath();
if(name.endsWith(".svn")) { if(name.endsWith(".svn") || name.indexOf("_text_") > 0) {
return; return;
} }
int removeThisLater;
// if(name.indexOf("\\test\\") >= 0) {
// return;
// }
if(file.isDirectory()) { if(file.isDirectory()) {
File[] list = file.listFiles(); File[] list = file.listFiles();
for(int i=0; i<list.length; i++) { for(int i=0; i<list.length; i++) {
...@@ -112,7 +113,6 @@ public class SpellChecker { ...@@ -112,7 +113,6 @@ public class SpellChecker {
if(!ok) { if(!ok) {
throw new IOException("Unsupported suffix: " + suffix + " for file: " + fileName); throw new IOException("Unsupported suffix: " + suffix + " for file: " + fileName);
} }
if("java".equals(suffix) || "xml".equals(suffix) || "txt".equals(suffix)) {
FileReader reader = null; FileReader reader = null;
String text = null; String text = null;
try { try {
...@@ -129,7 +129,6 @@ public class SpellChecker { ...@@ -129,7 +129,6 @@ public class SpellChecker {
scan(fileName, text); scan(fileName, text);
} }
} }
}
private void scan(String fileName, String text) { private void scan(String fileName, String text) {
HashSet notFound = new HashSet(); HashSet notFound = new HashSet();
...@@ -201,6 +200,9 @@ public class SpellChecker { ...@@ -201,6 +200,9 @@ public class SpellChecker {
if(!addToDictionary && debug) { if(!addToDictionary && debug) {
System.out.print(token + " "); System.out.print(token + " ");
} }
if(token.startsWith(PREFIX_IGNORE)) {
return;
}
if(addToDictionary) { if(addToDictionary) {
dictionary.add(token); dictionary.add(token);
} else { } else {
......
aacute about above abs absolute abstract accept accepts access accessed accessing aaaaaa aacute abalance able abnormal abnormally aborted about above abs absence
accessor according acirc acme acos across action active activity actual acute absolute absolutely abstract aca accept accepted accepts access accessed
adapter adapting add added addiction adding addition additional additionally addr accessible accessing accesskey accessor according account accounted accountid
address adds admin advanced advised aelig aes affect affected after afterwards accounts achieve achieved acid acirc acme acos acquire acquired across action
again against age agg aggregate aggregated aggregates agrave agreed ahead alan actions activate active actively activity acts actual actually acute adam adapter
alefsym alexander algo algorithm alias aliases aliasing align aligned all adapters adapting add added addiction adding addition additional additionally
allclasses allocate allocated allocation allow allowed allows almost alone along addr address addresses adds adjusted admin administration administrator admission
alpha already also alt alter alternatively always ambiguous amp analysis analyze adp advanced advances advantage advise advised aeiou aelig aes affect affected
analyzer and andy ang anon anonymous another ansi ant antivir any anything anyway affects after afterwards again against age agent agentlib agg aggregate
apache api apos app appears append applicable application applications applied aggregated aggregates aggressive agrave agree agreeable agreed agreement
apply appropriate approx approximate arbitrary are arg args argument arguments agreements ahead aid alan alefsym alert alexander algo algorithm algorithms alias
argv aring arising around arr array arraycopy arrays artifact asc ascending ascii aliases aliasing align aligned alive all allclasses alleging allocate allocated
asin aspx assert assign assignable assigned assignment asterisk asymp atan atilde allocation allow allowed allows almost alone along alpha already also alt alter
atomic attack attacker attacks attempted attr attrib attribute attributes auml altering alternate alternative alternatively alters altersequence always
author authorization auto autocommit autoincrement automatic automatically ambiguous amount amp amt analysis analyze analyzer and andras andrew andy ang
available avg avoid avoiding avoids back backed backing backs backslash backspace angel angle anne annual anon anonymous another ansi ant anti antivir any anyone
backup backwards bad bak balance base based basic basis bat batch bcc bdata bdquo anything anyway anywhere apache api apos app apparatus appear appeared appears
because become been before begin beginning behavior behaviour belongs below append appending appendix apples applicable application applications applied
benchmark best beta better between beyond big bigger biggest bigint biginteger applies apply applying appropriate approx approximate apps arbitrary arch
bin binary bind bit bitand bitor bits bitxor blob blobs block blockquote blocks architecture archival archive archives archiving are area areas arg args argument
blocksize blowfish bnf body bookkeeping bool boolean bootstrap border boston both arguments argv arial aring arising arithmetic arizona around arr arrangement
bound bounds bout brackets branch break breaks broken browser brute brvbar bsd array arraycopy arrays arrow arrows article artifact artifacts asap asc ascending
btree btrees bucket buckets buf buff buffer buffered buffering bug bugdatabase ascii ashcraft asin ask asked asp aspe aspx assert asserting assertion assertions
bugs build building built bull business busy but button bye byte bytea bytes assign assignable assigned assignment associated assume asterisk asymp async
cache cached cal calculate calculated calendar call callable callback called asynchronous atan atilde ation atom atomic atomically atomicity attach attached
caller calling calls can cancel cancelled cancels cannot canonical cap capacity attack attacker attacks attempt attempted attempts attorneys attr attrib
cardinality carriage cascade case cases casesensitive casewhen cast cat catalog attribute attributes august auml australia authenticated authentication author
catalogs catch caucho cause caused causes ccedil cdata cdd cddl cdup cedil ceil authorization authorized auto autocommit autocomplete autoincrement automatic
ceiling cellpadding cellspacing cent cert certain certificate certs cfg chain automatically automation autostart availability available average avg avoid
chained chance change changed changes char character characters chars charset avoided avoiding avoids aware bach back backed backend background backing backs
cheating check checked checker checking checklist checkpoint checks checksum chi backslash backspace backup backups backwards bad bahrain bak balance balancing
child children chinese cipher class classes classpath clause clazz clean cleaned bananas bar barcelona base based basic basically basis bat batch battery bbalance
cleaner clear clears clicked client clients clientside clob clone close closed bcc bcdfghklmnprstwz bdata bdfghklmnpqrst bdquo became because become becomes
closely closer closes closing clubs cluster clustered clustering coalesce code becoming been before begin beginning behalf behave behaves behavior behaviour
codes codeswitch coding col coll collation collations collator collect collected behind being bel believes belong belongs below bench benchmark benchmarks
collection collections collector cols colspan column columnlist columns com beneficial bennet best beta better between beyond bgcolor bid big bigger biggest
combinatorics combine combined combo combobox comma command commands comment bigint biginteger billion bin binary bind birthday bit bitand bitor bits bitxor
comments commit commits committed common commons comp compact comparator compare blackout blank blind blo blob blobs block blocked blockquote blocks blocksize
comparing comparison comparisons compatibility compatible compile compiled blog blowfish blue blur bmarks bnf boat bob bodies body bogus bohlen bold boo
compiling complete complex compliance compliant component compress compressed bookkeeping bookmarks bool boolean boot booted bootstrap border boss boston both
compression compressor compsci compute computed computer concat concatenate bottom bound bounds bout box brack bracket brackets branch branches breach break
concatenated concept concur concurrency concurrent cond condition conditions conf breaks broke broken browse browser brute brvbar bsd btree btrees bucher bucket
config configure conflict cong conn connect connected connecting connection buckets buf buff buffer buffered buffering buffers bug bugdatabase bugfix
connections cons consequential consistency consistent console const constant bugfixes bugs build building builds built bull bungisoft business busy but button
constants constraint constraints constructor constructs contain container bye byte bytea bytes cache cached caching cafe cal calculate calculated
containing contains content contents context continue continued contract calculates calculating calendar call callable callback called caller calling
contributors control conversion convert converted converter converting converts calls cally can cancel cancelled cancels candidate cannot canonical cap
copy copying copyright core correct correctly correctness correlated correlation capability capacity capone caps capture car cardinality care careful carriage
corresponding corrupt corrupted cos cost cot could count country counts coverage carrier cartesian cascade cascading case cases casesensitive casewhen cast cat
covered cpp crarr create created creates creating creation crlf cross css csv catalog catalogs catch catcher caucho cause caused causes cayenne cbc ccc ccedil
csvread csvwrite ctrl ctx cube cup curdate curren currency current currently cdata cdd cddl cdup cedil ceil ceiling cell cellpadding cells cellspacing cent
currval cursor cursors curtime curtimestamp cvs cwd cyclic daemon daffodil dagger central cert certain certificate certificates certified certs cfg chain chained
damage damages darr dash data database databaseaccess databases datalink datapage chaining chair challenge challenger chance change changed changelog changes
datastore datatype datatypes date dateadd datediff datetime day dayname changing channel char character characters charge chars charset chartered
dayofmonth dayofweek dayofyear dba dbo ddl debug dec decimal decision declaration cheating check checkbox checked checker checking checklist checkpoint checks
declare declared decode decoder decoding decompress decompresser decompressing checkstyle checksum cherries chi child children chinese choice choose chose cid
decrement decrypt decryption deep def default deferrability deferrable deferred cipher circle circumstances citizen city claim claims clancy clashes class
define defined definitely definition definitions deflate deflater deg degrees classes classloader classloaders classpath clause clazz clean cleaned cleaner
deinterleave delay delayed dele delegate delete deleted deleter deletes deleting clear cleared clearly clears click clicked clicking client clients clientside clo
delimiter delta demand denied dependencies dependent depends deprecated derby clob clone cloned close closed closely closer closes closing clubs cluster
derived desc descending describing description deserialization deserialize dest clustered clustering cmd cnt coalesce code codebase codebook coded codehaus codes
destdir destroy destroyed detailed details detect detected detection detects codeswitch coding coffee col coll collaborative collapse collateral collation
determ deterministic deutsch dev developer development diagram dialect diams collations collator collators collect collected collecting collection collections
dictionary did didn diff difference differences different digit digits dim collector color cols colspan column columnlist columns com combination
dimension dimensional dimensions dip dips dir direct direction directly combinations combinatorics combine combined combines combining combo combobox
directories directory dirs dirty disable disabled disables disclaimed disclaimer comes comma command commands commas comment comments commercial commit commits
disconnect disconnected disconnecting disk display displayed dist distinct committed committing common commonly commons communicate community comp compact
distributed distributing distribution div divide dividend divider division compacting companies company comparable comparative comparator compare compared
divisor dll dml dname doc doclet docs docsrc doctype document documentation comparing comparison comparisons compatibility compatible compensation compiere
documented documents does doesn dollar domain domains don done dos dot dots compilation compile compiled compiler compiling complete completed completely
double doubt down downloads driver drivers drop dropped drops dtd dual dummy dump complex complexity compliance compliant complicated comply complying component
dumps duplicate during dynamic each eacute eagrave early easily easy ecirc edit compress compressed compresses compression compressions compressor compromised
editing edu eee eeee effect effects egrave either eldest element elements elig compsci compute computed computer computers concat concatenate concatenated
else elsewhere embedded emergency empty emsp enable enabled enables enc enclose concatenates concatenation concentrate concept concerning concur concurrency
enclosed encode encoded encoder encoding encrypt encrypted encryption end endif concurrent concurrently cond condition conditional conditions conf config
endorse ends engine english enhancement enough ensp ensure entity entries entry configuration configure confirmed conflict conform conforming confusingly cong
enumeration environment eof eol epsilon equal equality equals equiv era err error conn connect connected connecting connection connections connects cons
errors esc escape escaped escapes espa essentials estimated eta eth euml euro consequential considerations considered consistency consistent consistently
evaluatable evaluated even event events every everybody everything everywhere consisting console conspicuously const constant constants constitute constitutes
exact exactly example except exception exceptions excluding exclusive exclusively constraint constraints constructor constructs construed consult consumes contact
exe exec execute executed executes executing execution exemplary exist existence contain contained container containers containing contains content contents
existing exists exit exp expand expands expected explain explorer exported expr context continue continued continues contract contracts contribute contributed
express expression expressions exps extend extended extends extensions external contributes contributor contributors control controlled controls convention
externally extra extract extracted extracter extracting facility fact factor conversion convert converted converter converting converts conveyed copied copies
factory fail failed fails failure fake fall false faq fashioned fast faster fatal copy copying copyright core correct correction correctly correctness correlated
feature features feed ferguson fetch few fid field fields fifo file filedata correlation corresponding corrupt corrupted corruption cos cost costs cot could
filename files filesystem fill filler fillers filter filters fin final count counted counting country counts course court coverage covered cpp cpu crarr
finalization finalize finally find finds fine finish finished fire firebird crash crashed create created createdate creates createtable creating creation
firebirdsql firefox first fitness fix fixed fkcolumn fktable flag flags flat creatively credit criteria critical crlf cross cruncher cryptographic
float floor flush flushed flushing fly folder followed following foo footer for cryptographically cryptoloop css csv csvread csvwrite ctrl ctx cube cup curdate
forall force foreign forever forget form format formatdatetime formats forms cure curren currency current currently currval cursor cursors curtime
forward found foundation four frac fractional frame fran frasl free fresh curtimestamp curve custom customer customerid customers cvs cwd cyclic daemon
freshmeat from front ftl ftp ftpguide full fulltext fully func function daffodil dagger damage damages darr dash dashes data database databaseaccess
functionality functions further future gamma gap garbage gcj gcjhack general databases datalink datanamic datapage datasource datastore datatype datatypes
generate generated generates generating generation generator generic genetic date dateadd datediff dates datetime datum day dayname dayofmonth dayofweek
genkey get getpart gets getter getting gif given glassfish global gmt gnu good dayofyear days dba dbcopy dbcopyplugin dbcp dbev dbid dbmonster dbms dbname dbo
goods google googlecode got governing gpl grabbing grammar grant grantable dbs dbserv dbsupport dbvis ddl deactivate deadlock deadlocks deal dealing death
granted grantedrole grantee granteetype grantor grants granularity greater greedy debug dec december decimal decision deck declaration declaratory declare declared
gregorian group grouped groups guest guid guide guides gzip hack half hand handle decode decoder decodes decoding decompress decompresser decompressing
handler handling happen happens hard hardware harr has hash hashcode hashed decompression decoration decrement decrypt decrypted decrypting decryption
hashing hashmap hashtable have having hazorea head header heading hearts height decrypts deemed deep deeply def default defective defects deferrability
hellip hello help helper here hex hextoraw hey hibernate hidden high higher deferrable deferred define defined defines defining definitely definition
highest hint historical history hit hits hmmss hms hoc hold holdability holes definitions deflate deflater deg degrees deinterleave del delay delayed dele
home hook hope hopefully horizontal host hostname hour hover how however href delegate delete deleted deleter deletes deleting deletion delimiter delivered
hsql hsqldb htm html http https huge human hyc hyt iacute ibiblio ibm icirc ico delivery delta demand denial denied dense depend dependencies dependency
icon identical identified identifier identifiers identifying identity ids idx dependent depending depends deploy deprecated depth derby derivation derivative
iexcl iface ifdef ifexists ifnull ignore ignorecase ignored ignorelist igrave derived desc descending descr describe described describes describing description
illegal image img immediately immutable impl implement implementation implemented descriptions descriptor deserialization deserialize deserialized designate
implements implicit implied import imported improve inc incidental include designated desired desktop dest destdir destroy destroyed destroyer detail
included includes including incompatibility inconsistent increment incrementing detailed details detect detected detection detects determ determining
indent indentation indented indents independent independently index indexed deterministic deusen deutsch dev developed developer developers development
indexer indexers indexes indexid indexing indicate indirect inet inf infin devenish deviation device devices dezign diagram dialect dialog diams dictionary
infinite infinity inflate inflater info information infringement init initial did didn died diff differ difference differences different differential differs
initialize initialized initializes initializing inmemory inner inplace input ins digest digit digital digits dim dimension dimensional dimensions dip dips dir
insensitive insert inserted inserting insertion inserts inside installation direct direction directly directories directory dirs dirty disable disabled
installer instance instanceof instantiate instead instr instruction int integer disablelastaccess disables disabling disadvantage disallow disappear disc
integrity intended interactive interesting interface interfaces interleave disclaimed disclaimer disclosed disconnect disconnected disconnecting
interleaving intermediate intern internal internally interpreted interrupted disconnections disconnects discontinue discount discovery discussion disk display
interruption intersect interval into inval invalid invalidate inversed invocation displayed displays dispose disputes dist distinct distinguishing distribute
invoke iota iquest isin iso isolation issue item items iterate iteration distributed distributes distributing distribution distributions distributor
iterations iterator its itself iuml january jar java javadoc javascript javax distributors district districts div divide dividend divider division divisor dll
jdbc jdbcx jdk jefferson jks join joins jpox jsessionid jsp just kappa keep keeps dml dname doc doclet docs docsrc doctype document documentation documented
kept kernel key keyalg keypass keys keystore keystores keytool keyword keywords documenting documents does doesn doing dollar domain domains don donate done
kill killed kind know known knows koders label labeled labels lambda lang donors dos dot dots double doubt down download downloads dproperty drafter
language languages laquo large larger largest larr last lastmodified late later drastic drda drive driver drivers drives drop dropped dropping drops dtd dual due
latest law layout lcase lceil ldquo leach leading leaf least left legal lehmann dummy dump dumps duplicate durability durable duration during dynamic dynamically
len length lenient less letter level lfloor liability liable lib license licensed each eacute eagrave earlier early ease easier easily easy ecb ecirc eclipse edit
licenses lifetime like limit limitations limited limits line linear linefeed edited editing editor edu eee eeee eeeeee effect effective effects efficient
lines lineup link linked links list listed listen listener listeners listing lite egrave eid eing eins either eldest electronic element elements elig eliminate elm
literal literals little live load loader lob lobs local locale locales localhost else elsewhere email emails embedded emergency employee empty emsp emulate
localized locate location locators lock locked locking locks log logged logger emulated enable enabled enables enabling enc enclose enclosed encode encoded
logging logic login logout logs logsize long longblob longtext longvarbinary encoder encodes encoding encrypt encrypted encrypting encryption encrypts end
longvarchar look lookup loop loopback loops loose loss losslessly lost lot low endif ending endings endorse ends enforce enforceable enforced engine engines
lowast lower lowercase loz lpt lrm lru lsaquo lsquo ltrim lucene lzf mac macr english enhancement enough ensp ensure ensuring enter entire entities entity
made magic magyar main major make making malformed management manager entries entry enumeration env environment environments eof eol epsilon equal
manipulation manipulations manually many map mapped mapping maps marc margin mark equality equals equitable equiv era err error errorlevel errors esc escape
marked marker mask masks master match matches materials math matter maurice maven escaped escapes escaping ese espa essential essentials estimate estimated
max maximum maxlen maxrows may maybe mdash mdd mdtm mean means meanwhile estimates eta etc eth euml euro eva eval evaluatable evaluate evaluated evaluates
mediumblob mediumint mediumtext mem memory menu merchantability merge merging evaluation even event events every everybody everything everywhere exact exactly
message messages met meta metadata method methods micro microsoft middle middot example examples exceeds excel except exception exceptions exclude excluded
might millis millisecond mime min mine mini minimum minor minus minute minutes excluding exclusion exclusive exclusively exe exec executable executables execute
mirrors mismatch miss missing mix mixed mkd mkdirs mmm mmmm mod mode model modes executed executequery executes executing execution exemplary exercise exercising
modification modified modifier modifiers modify module modulus month monthname exhibit exist existed existence existing exists exit exits exp expand expanded
more morton most move moved moves much mueller mul multi multiple multiply expands expect expected expenses experimental experiments experts expiration
multithreaded must mutable myself mysql mystery nabla name named names namespace explain explains explicitly explorer exponent exported exposed expr express
naming nano nanos nanoseconds native natural nbsp nchar nclob ndash necessarily expressed expression expressions expressly exps extend extended extends
necessary need needed needs negate negative negligence neighbor nested net extensible extension extensions extensively extent external externally extra
networked networks never new newline newsletter next nextval nlst nnnnnnnnn extract extracted extracter extracting face facility fact factor factory fail
nobody nodata node noframe non none noop nopasswords normal normalize normally failed fails failure fake fall falls false family faq faqs far fashioned fast
nosettings not nota notation notch nothing notice notified notify notin now faster fastest fatal feature features feb februar february fee feed feedback
nowait nsi nsis nsub ntext ntilde null nullable nullif nulls num number numbers feeds fees felix ferguson fetch few fewer ffeecc fff ffff ffffff fid field fields
numeric numsum nvarchar nvl oacute obj object objects obtain occur occurred fifo fifty file filedata filename filepwd files filesystem fill filled filler
occurrence occurs ocirc octal octet octype odbc odd odg off office offset ograve fillers filling filter filtered filters fin final finalization finalize
oid old oline omega omicron once onclick one online only onmouseout onmouseover finalizers finally find finding finds fine finish finished fire firebird
open opened opening openjpa operand operands operating operation operations firebirdsql firefox firewall first firstname fit fitness fix fixed fixes fkcolumn
operator operators oplus optimal optimistic optimizable optimization fktable flag flags flash flat flipped float floating floor florent flush flushed
optimizations optimize optimized optimizer option optional options oracle order flushes flushing fly focus folder followed following follows font foo footer
ordered ordf ordinal ordm oren org orig original orphan oslash other others footprint for forall force forces forcing foreign forever forget form format
otherwise otilde otimes ouml our out outer output outs outside over overflow formatdatetime formats formatted formatting formed forms formula forth forum
overflows overhead override overview overwrite own owner owners oymaurice package forward found foundation four fowler frac fractional frame frameborder frames
packaging padded page pages para paragraph param parameter parameters params frameset framespacing fran france frank frasl free freed french frequently fresh
paren parent parentheses parentid parse parsedatetime parser parses parsing part freshmeat friendly from front fsutil fsync ftl ftp ftpguide ftps fulfilled full
partial partially particular parts pass passed passes passive password passwords fulltext fully fun func function functional functionality functions funktionen
pasv path paths pattern pdf people per percent performance permil permission further future fuzz games gamma gap garbage gast gaussian gave gcc gcj gcjhack
permissions permitted permutation permutations perp persistent phantom phase phi gecko gem gen genealogy general generally generate generated generates generating
php pieces pinned piv pivot pkcolumn pkcs pktable place plan planned plans generation generator generic genetic genkey george geos german get getpart gets
platform please pluggable plus plusmn png point pointer pointers points poll pool getter getting ghi gid gif give given glassfish global globally glossary gmail
poolable pooled pooling pop populated port portions pos position positioned gmbh gmt gnu goes golden goldenstudios good goods goodwill google googlecode got
positive possibility possible post postgre postgres postgresql potentially pound gov governed governing government gpl grabbing graceful grammar grant grantable
pow power pre prec precision preferred prefix prep prepare prepared preparing granted grantedrole grantee granteetype grantor grants granularity graphical
prepended preserve previous primary prime primitive print println prints prior greater greedy greenspun gregorian groovy gross group grouped grouping groups
priority private privilege privileges probably problem problems procedure grows guarantee guaranteed guest gui guid guide guides gutierrez gzip hack had
procedures process processed processing procurement prod produces product haidinyak half hallo halt hand handle handler handling hans happen happened
products profits programme programs progress prohibited project promote prop happens hard harden harder hardware harm harmless harr has hash hashcode hashed
properties property proposed protected protocol provide provided provider hashing hashmap hashtable have having hazorea head header headers heading heap
provides provisions pseudo psi pub public published purpose push put pwd hearts height held hellip hello helma help helped helper helpful helvetica here
qualified qualifier quantified quantifieds quarter queries query queryframework hereafter hereby herein hereof hereunder herkules hex hexadecimal hextoraw hey
queue quick quicker quickstart quiet quit quot quote quoted quotes quoting race hibernate hid hidden hide hideg hiding high higher highest highlight highly
radians radic radix rand random rang range ranges raquo rarr raw rawtohex rceil hilbert hint his historical history hit hits hkey hmmss hms hoc hoi hold
rcon rdbms rdquo read readable reader reading readonly reads real really reason holdability holding holes home hook hope hopefully horizontal host hostname hot
reasons rebuild rebuilt rec recalculate receive received recently recipient hour hours hover how however href hsql hsqldb htime htm html http https huge
reclaimed recompile reconnect record records recover recovering recovery recurse human hundred hungarian hyc hypersonic hyt iacute ibiblio ibm icirc ico icon
recursion recursive redirect redistribute redistribution redistributions redo icons idea identical identified identifier identifiers identifying identity
reduce ref refactor refactoring reference referenceable referenced references idiomatic idle ids idx idxname ietf iexcl iface ifdef ifexists ifnull iframe
referencing referential reflect refresh reg region register registered regression ignore ignorecase ignored ignoredriverprivileges ignorelist ignoring igrave
regular rehash rein reindex rejected rel related relations relationship relative ikemoto ikeyan illegal image img immediately immutable imola imp impl implement
release releases relies remainder remaining remark remarks remember remembered implementation implementations implemented implements implicit implied import
remote remove removed removes removing rename renamed renaming repeat repeatable important imported impose impossible improve improved improvement improvements
repl replace replaced replacement replied reply repo reported represents improves improving inability inactive inc incidental include included includes
reproduce request requested requests required requirement requires res reserve including incoming incompatibilities incompatibility incompatible inconsistent
reserved reset resets resin resolution resolved resolver resource resources rest incorrect increase increased increment incremental incrementing incubator
restart restoring restrict restricted restriction result resulting results ret incurred indemnify indemnity indent indentation indented indents independent
retain retr retrieve return returned returns reuse rev reverse reversed revision independently index indexed indexer indexers indexes indexid indexing indicate
revoke rfc rfloor rho right rightmost rights rlm rmd rnd rnfr rnto role roles indicates indirect indirectly individual individually inet inetsoftware inf infin
roll rollback rolled rolls root roots rot round rounding roundmagic rounds row infinite infinity inflate inflater info infoq inform information informed
rowcount rowid rownum rows rowsize rsa rsaquo rsquo rtrim rule rules run rundll infringed infringement infringements infringes infringing ini init initial
runnable running runs runscript runtime rws safari safe said salt salz same samp initialization initialize initialized initializes initializing initially initiate
sample save savepoint savepoints saves says sbquo scalar scale scan scanned initiation inject injection injections injury inline inmemory inner inno innodb
scanners scanning scans schem schema schemas schemata schmorp school scm scope inplace input ins insecure insensitive insert inserted inserting insertion
scott script scroll scrollable sdot search searchable searched searcher searches inserts inside install installation installations installed installer installing
searching second secondary seconds sect section secure security see seed seek instance instanceof instantiate instead instr instruction instructions instrument
seems select selectable selected selection selectivity selects self selfhtml send int intact integer integers integrate integrated integration integrity
sending sense sensitive sentence sep separate separated separator separators seq intellectual intended inter interaction interactive interesting interface
sequence sequences serial serializable serialization serialize serialized server interfaces interleave interleaving intermediate intern internal internally
serverlist servers service services servlet session sessions set sets setters international internet interpreted interprets interrupted interruption intersect
setting settings sha shall shallow share shared shift short should show shown interval into intra introduction intuitive inv inval invalid invalidate inversed
shrink shuffle shut shutdown shutting shy side sides sig sigma sigmaf sign invocation invoice invoiceid invoke iota ipowerb iquest isin iso isolated
signature signed signs signum silently silly sim simple simplify simulated sin isolation issue issued issues item items iterate iteration iterations iterator
since single singleton site situations sixty size sizes skip skipped sleep slock its itself iuml iyama jackrabbit jackson jakarta jam james jamwiki janino january
slow slower small smalldatetime smaller smallint snoozesoft socket sockets japanese jar jars jasonbrome java javadoc javadocs javaforge javascript javax
software solution solve some somebody somehow something sometime sometimes sort javolution jcr jdbc jdbcx jdk jee jefferson jenkov jetty jim jks jndi job joe
sortable sorted sorting soundex source space spaces spades span spec special joerg johann john johnson join joined joins jon jones jpa jpackage jpox jroller
specific specification specified specifies specify specs speed spell spi split jsessionid jsmooth json jsp jsr jsse jts judgment judicial julia jun june junheng
sql sqlexpress sqlite sqlnulls sqlserver sqlstate sqlxml sqrt src ssl stack stage jurisdiction jurisdictions just jvm kappa karin keep keeps kept kernel
standalone standard stanford start started starter starting starts startup kernelpanic key keyalg keying keypass keys keystore keystores keytool keyup
starves stat state statement statements states static status stay stddev stddevp keyword keywords kill killed killer killing kind kindergarden kinds kit know
step still stmt stop stops stor storage storages store stored storepass stores knowledge known knows koders koi label labeled labels lambda lamp lang language
str strange strategy stream strength strict strictfp string stringdecode languages laptop laquo large larger largest larr last lastmodified lastname late
stringencode strings stringtoutf stru struct structures students style stylesheet later latest law layer layout lcase lceil lck ldap ldbc ldquo leach lead leading
sub subdirectories sube subject submit subqueries subquery subset substitute leads leaf least leave leaves leaving lee left leftmost legal legend lehmann len
substr substring subtract subtree succeed successful successfully such suffix length lenient less let lets letter letters level levels lfloor liability liable
suggest suggested suite suites sum summary sun sup supe super superseded lib libraries library licensable license licensed licenses lies lifetime like
supertable supplied support supported supports sure svn swap swapped switch likely lim limit limitation limitations limited limiting limits line linear
switched switches sxd sync synchronization synchronized synonym syntax sys linefeed lines lineup link linked linking links linux list listed listen listener
sysdate sysdba syst system systems systime systimestamp szlig tab table tables listeners listening listens listing lists lite literal literals litigation little
tabs tag tags tail takes tan tape tapes target targets task tasks tau tcp live load loaded loader loading loads lob lobs local locale locales localhost
technology temp template templated temple temporarily temporary term terminated localization localized locally locate located location locators lock locked
terms tertiary test testing tests text than that the them then theoretically locking locks log logfile logged logger logging logic login logins logo logout
theory there therefore these theta thetasym they thin thing thinsp this thomas logs logsize long longblob longer longtext longvarbinary longvarchar look
thorn those thread threaded threads three throttle through throw throwable thrown lookahead looks lookup lookups loop loopback loops loose losing loss losses
throws ticker tid time timeout times timestamp timestampdiff timestamps timezone lossless losslessly lost lot low lowast lower lowercase lowest loz lpt lrm lru
timezones timing tiny tinyblob tinyint tinytext tired title tmendrscan tmfail lsaquo lsquo ltrim lucene luntbuild lynx lzf lzma mac machine maciej macr made
tmjoin tmnoflags tmonephase tmresume tmstartrscan tmsuccess tmsuspend today todo magic magyar mail mailer mailing main mainly maintained maintenance major make
together token tokenize tokenized tokenizer tokens tom too tool tools top topic makes making malformed malfunction management manager manipulate manipulation
toplink tort total trace traces trade trailing trans transaction transactional manipulations manual manually many map mapped mapping maps marc marcy margin
transactions transfer transform transient transitional translatable translate marginheight marginwidth mark marked marker martin martina mary masahiro mask
translated translates translation translations tray tread tree trick tried tries masks master masterkey match matches materialized materials math mathematical
trigger triggered triggers trim true truncate truncated truncates trunk try matrix matter matters maurice maven max maximum maxlen maxlength maxrows may
trying tucker tune tutorial twice two txt type types uacute uarr ucase ucirc udts maybe mdash mdd mdtm mean meaning meaningful means meanwhile measure measured
ugrave uid uml unaligned uncaught unclosed uncommitted uncompressed under mechanism media median medium mediumblob mediumint mediumtext megabytes meier
understand understands understood undo undocumented undone unencrypted unescape melbourne mem memory menu merchantability merchantable merge merged merging
unexpected unicode unindexed union unique uniques universal unix unknown unless message messages met meta metadata meteorite meter method methods micro microsoft
unlink unlinked unlock unmaintained unmodified unnamed unnecessarily unnecessary middle middot midpoint might migrate migrated migration miguel miller millis
unquoted unrecoverable unrelated unscaled unset unsigned unsorted unsupported millisecond milliseconds mime min mine mini minimum minor minq minus minute
until untranslated unusable unused unwrap unwritten updatable update updated minutes mirrors misc miscellaneous misconfigured mismatch miss missing mix mixed
updates updating upgrade upload upper uppercase upsih upsilon uri url urls usa mixing mkd mkdirs mmm mmmm mod mode model modes modification modifications
usage use used useful user username users uses using usually utc utf util modified modifier modifiers modify modifying modular module modules modulo
utilization utils uuid uuml val valid validate validation validity value values modulus moment mon monday money month monthname months more morton most mouseover
var varbinary varchar variable variables variance variant various varp vector move moved moves moving mozilla mpl mrpersister mssql msxml mtsystems much
vendor versa version versions very vice view views violated violation virtual mueller mul multi multiline multiple multiplication multiply multithreaded
viruses visible visitor vldb void volatile vpn wait waiting wants warning multithreading must mutable mutually mvcc mydb myself mysql mystery nabla naive
warnings warranties warranty was watchdog way weak web week weierp weight weights name namecnt named names namespace naming nano nanos nanoseconds nara nations
weird well what when where whether which while whirlpool white whitespace whole native nativej natural nature navigate navigation navigator nbsp nchar nclob
why width wikipedia wildcard will win windows wish with within without wlam ndash necessarily necessary need needed needs neg negate negation negative
wondering word wordid words work workaround worked working works world worst negligence neighbor nest nested net network networked networks never new newer
would wrap wrapper writable write writer writes writing written wrong www xads newline newly neworder news newsfeed newsgroups newsletter next nextval nissler
xaer xares xid xlock xml xmlattr xmlcdata xmlcomment xmlnode xmlstartdoc xmltext nlst nnnnnnnnn nobody nodata node nodelay nodes noframe noframes noll non none
xor xtea xtime xyz yacute year yen yes yet yield yielding ymd you your yuml yyyy noop nopasswords noresize normal normalize normally nosettings not nota notation
zero zeta zip zone zwj zwnj notch note nothing notice notices notification notified notifies notify notifying
notin notwithstanding now nowait nowrap nsi nsis nsub ntext ntilde nul null
unit abc samples compacting email phone jones john bob abcde nullable nullif nulls num number numbers numeric numerical numsum nvarchar nvl
matrix probable cartesian samples polar newsfeed oacute obey obfuscator obj object objects obligation obligations obtain obtained
rss disallow pending download stable scripts longer contained modules machine proposal exits bugfixes jun depending persisted thu roadmap channel production quality obtains occur occurred occurrence occurrences occurs ocirc octal octet october
undefined unsafe sam overwritten reside samples abnormal termination octype odbc odd odg off offer offered offering offers office offset often ograve
amount samples invoice bench oid okay old oline omega omicron once onchange onclick one ones onfocus onkeydown
phone cnt terminal orders think response uniform warehouses neworder price delivered quantity stock districts city warehouse customers delivery district discount keying street orderid customer supply lim payment lastname amount credit loading tax ytd carrier onkeyup online onload only onmouseout onmouseover onreadystatechange onresize
eing bench cally bar ese uniform lastname anti ation pri ought city able pres onsubmit open opened opening openjpa openlinksw opens opera operand operands
phone bench cnt terminal orders threshold midpoint namecnt uniform warehouses price tpc quantity city districts stock warehouse customers district delivery discount street customer supply lim payment amt lastname amount deck credit ytd tax carrier operating operation operations operator operators oplus optimal optimistic
bench hallo welt sequential optimizable optimization optimizations optimize optimized optimizer option
accounts bid tpca bbalance account branches htime tbalance teller tellers tpc aid able abcdefghijklmnopqrstuvwxyz abalance optional optionally options ora oracle orange oranges order ordered orderid
trial depth cpu xrunhprof maciej wegorkiewicz destroyer killer testtab student ordering orders ordf ordinal ordinary ordm oren org organization organized orig
ruebezahl wide crash hallo welt expect synth shortest halt news oranges apples origin original originals orld orphan oscar osgi oslash other others otherwise
otilde otimes ought ouml our out outer output outs outset outside outstanding
possible time modulus processed results foundation truncated suites overflows approximate location body continue zone trunk overwritten escaped first times detected modify recovering superior abstract result setters said module ways never those accounts places input unmodified core sect emergency character function implicit lenient grouped age interleave implied runs effect suggested mac corrupt selects comparator subtree checkpoint client sales third raw closely delegate country sets optimal users weak codes web tutorial okay super option price interrupted applications three logging channel disconnect save naming connection rights bin fields space encrypted cafe warranty any cent aligned over overall overflow overflows overhead override overview overwrite overwritten
byte transform bigger done cot mix decision contain backups best copying readable illegal actual release news insecure inc allow invoice bound revision frame quarter year advanced locks systems future root networks begin register pointers scanned useful hot era calculate ins rounds warehouses string balance appear line preserve seed modes please the search includes restricted hint unless occurs consistent you servers exactly encoded reclaimed regular closed arrays outer listening overview arch goods gap immutable net vice amp row developer understand grammar degrees poll myself renaming today removing connected place mode disable assignable closes shown here named english divide own owned owner owners ownership oymaurice pack package packaging padded padding
linked information consistency people during plans say use swap anyway cause been visitor meanwhile optional clubs estimated untranslated must limited zero exceptions working measure validation without fifo loops combined owner escapes percent property could says completed easy cleaned tau stores constants advised flushed problems store generation switched based corresponding handle basis removes kill nanoseconds next cpu threshold tracking returns who progress related now promote exported invalidate negative sure retrieved quantity view unquoted against pooled resolver shall remarks cross delta while ascii old indexed searches track enabled necessarily union inconsistent page pages pair pairs pal panel panels papa paper para paradox paragraph
ought mutable provided drivers schemata side collation benchmark digital decoding install denied detailed numeric tree james strategy imported strings base hopefully parsing loose prior carriage built parameter down stops together cat extends prop much sorted second washington debug medium inflate parser holes handling rang online commit quadratic case objects under pass invalid essentials uniform safe lower collected filler moves uses cyclic upgrade large ansi resolved supports common nothing exact such installer quotes seek standard collations parent writing start indexers lot pinned correlation restriction response home variables warning thing float quantified vendor keying disabled customer range paragraphs param parameter parameters params paren parent parentheses parentid
removed text samples temporary classes provider false display concatenated lines inserts waiting column session hook peace negate sometime direct dummy dump before using switches undefined sum handler logs tokens dependent literals called few things documented instantiate build full join hex committed support pending compiling chair multiply fill math main enclosed dual blocks methods knows menu other comma district street cast calculated quote adds frank hashed forward elsewhere connect extended complex otherwise events write privilege according attack position message resolution deep modules monday become preparing lock permissions daemon horizontal delivered would backing got bundle execute parse parsed parsedatetime parser parses parsing part partial partially
faster dagger maybe sin tan mirrors immediately rein compress link pilot over found radix syntax returned divider beginning two ends declaration unnamed registered caller listed argument sites ibm tray deleting will greedy distributing condition processing trip self cardinality consequential own loader dots what divisor postal enough latest creating releases coffee new buckets factory hold options referenced blobs variant understands print source restrict translation mark end trailing finally align separator usage already searcher stock list spots started converted genetic bits generated still should compatibility epsilon dictionary shared reader field subject are collector stage embedded unsafe enclose fake template reuse participant particular parties partition parts party pass passed passes passing
expect wrapper parses sequences links quicker open prepared descriptor tool permission explorer interleaving relies generates long scalar searched sessions signature detect preferred student prevented papa commands about trim collect starting stopped res miller items polar bit win clause busy evaluated stopping unlinked cursors appears mary reproduce requirement creation above isolation data guide targets permutation able interpreted mechanism harm editing padding environment bob successful sorting traditional contents inflater domains hover trick tags constructs throw matter tested reduce fillers apply shrink hour last reason quiet occur good positioned tea redirect history oracle once bench avoiding bootstrap passive password passwords past paste pasv patch patent patents path paths
form whitespace quoted specific cascade notice how check updated complete cannot extend upper way unlock arbitrary compute manipulation branch hidden prepare recurse auto identical password transactions very chain moved delivery current contains words status simplify interval reverse strength unvisited everybody transitional site look minute project mystery queries internal package interesting buff declares fly fully reset hits properties wants extensions documents letter finished snapshots switch clustering increase day put joins granularity feed swapped filters primitive paragraph triggered additional yet has return nest needed scroll messages easily internally division indexing products expressions pattern patterns pause pay payment pdf peace peek pencil pending people per
students wrong bout high referencing locate views anon cipher pencil mean daffodil fails documentation below fire level threads contributors endorse followed copy itself merge derby apples office unix saves group dependencies increment made activity supported integer hack abnormal nested silly same analysis recently merging synonym trying skipped dropped four enable converts transaction round attempted err gets exists through attributes secondary override entry insert variance intersect warranties received pole functional disables automatically account escaping bananas aliasing again enumerate transfer proposal thread expected provisions dirty precision reserve relative access microsoft imp fast percent perform performance performed period permil permission permissions
sense exclusively declare hashing files doesn scan passed manually somehow our blue signs than indent mismatch test post serial infinite viruses blowfish var restoring does manual quick functions helper contained relationship met separated timing cup affect certain loading force method killed leave record backslash close update profits branches tasks bookkeeping pooling dividend applied aggregated rebuild comparison computed pound passive more its back surrogates general took issue spy work native clicked indirect bull indented patch shut combination arising file forum workaround implementation exits sign cache crashed total prohibited retain another accept deferred phantom delimiter containing types both permits permitted permutation permutations perp persist persisted persistence
defined salary miss inserting assign octal clean dip weight compacting aliases unrecoverable detection encoder max specification enables match descending decode skip january human yes less halt differences conditions school cases settings sup flag missing rolled distributed atomic matrix statistics effects decoder reference region dumps button char tin constructor term tests operand used throttle disconnecting converter magic corrupted them compatible purpose operands encrypt selected task allows this cheating maps starter acute happens allocation interactive disclaimed teller walk query outside border nobody name network secure iterations flush dimensions bar violation undone iteration change logged twice persistent persister person personal persons pete peterson petra pfister pgdn
fresh overflow collection mask caused dot tapes compare compared layout values resources variable actually around edit cursor encoding continued governing loaded conflict anonymous break chained bucket constraints therefore collecting offset potentially alternate revoke trade yielding retrieve unnecessarily equals successfully oranges salz protocol identity orders true fetch grant referential everywhere references decimal rename sending building service represents fix try instrument brackets correctness shortest example better canonical forget procedures universal uncaught description problem guides specify hard breaks bach only schemas bid changing extra alone expression probably nulls licensed dips rest empty exemplary pgup phantom phase phi philip phone php phpversion phrase phrases physical pid
fail for engine header express with from chance error version child boat direction reading necessary every browser rounding format trigger append speed requests attribute compiled relations permutations comment versa filter submit padded attacks replacement subtract initial server sentence action important required existence delete substitute sides formats however wondering was know spades tape reconnect pointer socket reserved footer writes width atom available traces statement aggregates all plus calling clustered number read guest disallow don renamed tertiary entity not hope low technology reply mapping anti sun dollar short materials pattern proposed inside midpoint unmaintained executed simulated concur create piece pieces pilot ping pinned pipe piv pivot pkcolumn pkcs pktable place places
weights coding pop reported licenses memory shy hey ranges databases theoretically parse bug recover resets displayed procedure cube show generator children constant unique lifetime race tucker attacker larger modified ordered keep newsletter delay your copyright insensitive including stable timeout externally smaller make pool remote added recursion listeners notify broken ignore software either strange conforming optimistic updates directories left host normally normal flags image customers difference thin discount pair beta assigned tcp shutdown unlink logic virtual xvi credit step pseudo overwrite installation points code out that queue style mer one word rows directly almost details content originals invoke brute well intended map plain plaintext plan planned plans platform platforms play please pluggable
carrier jefferson author directory when terms address september then takes ordinal alias solution bind sometimes just seconds slow hello correlated little tired equal forcing key drop programs dropping errors silently enhancement features higher binary duplicate donate translations elements minor product applicable call digit where columns labels linear keyword infringement collections truncate cancel walker weird demand facility plain unaligned dash selection external entries array agreed paths configure clients state recompile cached tune white verified disconnected management languages face least scans tellers searching real recipient stub primary limits see output minimum into definition final hash single tom groups reasonable plugin plus plusmn pmd png point pointer pointers pointing points polar pole
persistent replaced derived rehash logger obtain log prime special subset profile roll supplied tabs command checked combinatorics writer feature portions profiler instead move unsorted invocation fitness take concurrency block bytes avoid contact uncompressed yield sam names event originally private qualifier conversion resulting comments unusable power paper something global getting half marked undo feeds integrity rolls really executing pairs simple untested maximum ensure damage delayed remainder strict automatic some matches storage streams port vertical addiction closer published volatile martin redistribution grants except platform heap damages stack stored order factor until alternatively tools biggest backwards polepos poleposition poll polling pool poolable pooled pooling pop populated
odd protected concurrent wait packaging find business static created many commons statements written slower replied generic depending adapter void resin exist huge logout needs writable destroyed comparable validity wood payment millisecond historical pub bad collator within unused suggest tag tab requested rid wish like convert cap reversed sampling scripts kept salt modifier tried include consistently date runnable explain tiny path bye encode looks alpha warehouse may natural token default masks opening opened identifiers quit stop owners big garbage duration cancels permitted distinct largest backed wrap public suffix hand implemented versions fin generating diagram sensitive minus expands jar component ticker population port portability portable ported porting portions portlet ports pos
converting ascending liability floor equality cost listen commits employee backspace sugar email extracted bat random database top always supposed forever notified after checksum boolean operation did numbers object middle section bsd infinity computer deleter interface startup running compliance late production artifact later reflect shouldn loss singleton absolute node dimensional unsigned encryption violated avoids checking looking didn listing thrown page distribution happen flushing success refresh free specifies dialect cartesian comparing rules sizes detects tread week double profiling chars eldest rot role correctly point city mapped failure capacity user having sixty meaning bugs remark passwords scanning droop receive position positioned positions positive possibility possible possibly post postal
trial privileges head world identifier truncates request translates parts console restart pieces redistributions somebody improve meta destroy help thorn sue seems particular provides throws sleep boston security alter rebuilt kernel send exclude accepts language recovery license populated cleaner identifying fashioned lookup item contract leaf checks everything planned sentinel import making temple clears specified priority right along superseded sat add type even highest remove understood amount iterator pages label run tax off plan login original stream indents algorithm law hardware overhead unwrap declared persisted recursive districts application active define catch smith prepended fine deterministic roles unwritten finish posted postgre postgres postgresql potentially pound pow power poweroff pox
characters currently included uncommitted have suite shallow remaining these checker extracting exception ceiling worst replace arguments windows indexer quoting unit rejected length comparisons upload soap filename belongs doubt separators fatal boo drops deferrable quality chinese runtime insertion known think worked clone van procurement sequence most following each provide prefix aid flat front pivot connects adding tell depth implement valid visit split locking depends sequential passes load cons reside keeps unexpected else present hit per sockets listener solve execution succeed reasons tables dimension get sub threaded target sample storages machine shutting accessed compile probable vector compression restore practice prd pre prec precision preferdoslikelineends preferences preferred
rightmost works limit connecting stay produces limitations calls disclaimer whether describing inserted updating sort records requires compressed acquired deletes expand lookahead they aggregate validate correct clear undocumented none control theory forms separate operator changed coverage push ant setting compact dynamic non intern selectivity repeatable prints which literal currency enumeration foreign manager representative incidental locked rule warnings icon but system performance value greater basic longer leading exit appropriate triggers addition various because cherries adapting loop margin certificate span and sized reads shuffle scanners can legal null others acme container additionally previous generate interruption prefix prefixed premature prep prepare prepared prepares preparing prepended pres
size combinatoric month locators class remembered money terminated live buffered cluster share lee buffer implements allocated too operating kind title dim topic whole covered starts backs hid driver need allocate translated fall afterwards roots interfaces scope backup states assignment concatenate finds buffering ahead keywords intermediate batch testing lost indicate instance lambda digits given partial count services allowed dos keys since definitions concept liable translating existing calendar excluding networked scale process negligence independent fractional usually summary repeat multiple tries independently supply mail resource schema also element orange unknown starves shift failed remember disk why heading functionality present preserve press prev prevent previous previously pri price primary prime
index connections excluded might between gamma ignored regression translate modifiers marker changes local context indexes different parameters whirlpool substring grabbing set domain visible model modification phone table family simply newline script anything part development exclusive fact mixed small tail john phase orphan coalesce operations deleted redistribute fixed means accessing granted select possibility hearts crash ambiguous executes termination extract creates definitely australia notch inner terminal positive constraint escape folder there unsupported outs height manipulations qualified document trace intact assert blob spaces major wide translatable identified counts combine early affected deck signed situations primitive primitives print println prints prior priority private privilege
closing master privileges probability probable probably problem problems proc procedural
procedure procedures process processed processes processing procurement prod
authorization unencrypted merchantability finalization initialization utilization refactoring optimization subdirectories decompressing initializing hexadecimal decompresser initializes initialized synchronized optimizations serialization transactional produce produces product production products profile profiler profiling profits
program programme programming programs progress proguard prohibited prohibits
compliant timezone rollback unscaled analyzer optimize localized deflater hibernate snippets watchdog serialized inversed finalize normalize decompress standalone decryption uppercase behavior serialize scrollable download sortable uncomment pluggable optimized callback tokenized timezones initially initialize lowercase deprecated randomized optimizer registry callable malformed catalogs checklist linefeed timestamps project projecthelp projects prominent promote prompt promptly proof prop
propagated properly properties property proposal proposed prospectively protect
datediff datatype xmltext stddev bitxor currval openjpa rownum hsqldb dayname upsert xmlattr thomas params postgre analyze xmlcdata decrypt nullable mueller tinyint ifexists systime curdate radians ifnull substr apache subquery bitand datalink concat unicode sysdate grantee toplink smallint nextval casewhen xmlnode varchar hextoraw testall rawtohex struct toolbar lucene locale postgres catalog tostring soundex nullif readonly roadmap welt mod desc acos lcase steve init atan jones url ref clob col param java args throwable dir expr util http btree multi sql info pos obj stat int utils todo config prep temp lob savepoint rec jdbc html app org println cols conn synth min com timestamp len idx admin protected protecting protection protects protocol protocols prototype prototyping
prove proven provide provided provider provides provision provisions proxy pseudo
abc metadata sqrt nosettings servlet bigint seq righthand gmail nopasswords hallo anne postgresql val ignorecase buf arg jpox mysql joe str psi pub public publish published publishing pure purl purpose purposes pursuant
push put pwd pwds qty quadratic qualified qualifier quality quantified
qty foo meier impl parsedatetime caucho stringencode eid pre instr ucase dateadd scott sha johann roundmagic sabine www varbinary lang javax petra aes fulltext asin yyyy xml nodata fktable curtime doc quantifieds quantity quarter queries query queryframework querying questions
formatdatetime cos longvarchar samp simon uuid lehmann kindergarden const rand octet gmt avg rdbms xyz exp rtrim ltrim rekord stringtoutf monthname queue queues quick quicker quickly quickstart quiet quirre quit quite quot quote
quoted quotes quoting race radians radic radio radix ram ramiere rand random
rss xmlstartdoc asc runscript marc odbc usa txt xmlcomment eins def johnson blockquote ddl color addr zip karin api susan mem cal https jon classpath xtea pfister unionall dec svn jackson randomized randomly rang range ranges rank rapid raquo rarr rate rather ratio raw
rawbyte rawtohex rceil rcon rdbms rdquo reach read readable reader reading
gcj grantor glassfish hoi gnu tpca google bak numsum btrees maven clancy poleposition yen keyalg unescape implies tpc rhino structures readonly reads ready real really realtime reason reasonable reasonably reasoning
sigma env iterate millis algo uml reasons rebind rebuild rebuilding rebuilt rec recalculate receipt receive
received recently recipient recipients reclaimed recognized recommended recompile
mediumint combo george recompiles reconnect reconnecting record records recover recovering recovery
recreate recreated recurse recursion recursive red redirect redirected
rev toraw zeta xor zeile februar dll tinyblob nnnnnnnnn redistribute redistribution redistributions redo reduce reduced reduces
redundancy redundant ref refactor refactoring reference referenceable referenced
neighbor bcc cfg argv namespace lib vldb mmmm ntext references referencing referential referred refers reflect reflection refman
reformed refresh reg regexp region register registered registry regression
specs hashcode quickstart upc mini equiv andy mediumtext attrib unclosed kappa ffff micro png orig eeee getpart killer ceil incremental stanford tokenize hans guid jndi agentlib nasty keytool rebind eth firebirdsql tohex fuzz wikipedia utc slock wiki noframe marcy systimestamp mediumblob wizbang gregorian clientside destroyer transient cwd rsa freshmeat stru prod omega uri stocklevel bitfield nsis regular regularly regulation rehash rein reindex rejected rekord rel related
relating relational relations relationship relative relatively relaxed release
explicitly tinytext apps yjpagent instruction deploy iota approx multithreaded downloads omicron sec leach safari deg nan unnecessary lineup peterson cellspacing rel bigdb selfhtml hostname nchar wildcards euro released releases releasing relevant reliable relies reload rely remain remainder
remained remaining remains remark remarks remember remembered remote remotely
locales jdk cancelled mkdirs ssl lru spec src wildcard isnull deflate zloty docs dayofyear bitor bnf csv datetime vpn jsp username utf gaussian cid attr lastmodified dateformat cert trans serverlist inplace refactor poolable catcher csvread exe jdbcx pwd sqlxml gif esc mime clazz ico localhost gcjhack searchable certs redo savepoints tid rowid endif css longvarbinary invoiceid enc cond jsessionid dbs func javadoc sys del gen div dml sync ftp javascript lobs exec diff reindex neworder comp morton conf prec signum tokenizer nanos grantable smalllob joerg withmargin mmm createdate agg fromlist hashentry dist proc dest rowsize abs hms pow nclob lzf tovaluetype ids nstring customerid nonunique datastore href fid ymd dayofmonth num ret remove removed removes removing rename renamed renames renaming repair repeat
repeatable repeated repeatedly repl replace replaced replacement replaces replied
nowait arraycopy sid idxname hashmap ifdef instanceof schem updatable xid pktable parentid holdability unrelated inv ready urls pdf auml rws ferguson dba img programme pasv tmfail poweroff maxlen dayofweek columnlist eol stylesheet unset coll ctx sig dtd cvs dirs xrunhprof jim inter dbo eof reply repo report reported reporting reports repository represent representation
representations representing represents reproduce reproduced req request
repo scm googlecode charset rowcount maxrows datatypes antivir edu optimizable loopback bounds lite firebird sqlite quot nbsp combobox gzip losslessly gzip hashtable rundll snoozesoft newsfeed iso faq htm docsrc requested requests require required requirement requirements requires res
sxd cpp dev nsi crlf odg regexp reg inmemory ldbc nodelay bool logfile logsize hsql csvwrite lastname amt byname cnt ytd lim namecnt eing lastname cally ation pri ese pres bugfixes resellers reserve reserved reset resets reside resin resistant resolution
stringdecode inet filesystem xlock deutsch fran espa sysdba sqlserver bytelen spi sqlstate autoincrement beyond resolved resolver resort resource resources respect responding response
serializable rfc paren ctrl cial datapage hoc cdata bdata unindexed xads rcon mul xtime theta filedata responsibility responsible rest restart restore restored restoring restrict
rmd firefox stor mkd rnto nlst noop retr cdup mdtm syst dele rnfr hmmss ftpguide mdd restricted restriction restrictive restricts result resulting results resume ret
onclick alt onmouseout udts onmouseover eee decrement mine nano occurred subqueries compressor blocksize retain retr retrieve return returned returning returns reuse reused reuses rev
casesensitive gpl ibiblio codeswitch sep stddevp varp asterisk sqlnulls compsci wlam strictfp nvl determ deinterleave revealed reverse reversed revised revision revoke revoked rfc rfcs rfloor rgb
iface hyc aspx alan koders lpt uid bytea longtext oid smalldatetime longblob nvarchar inf jun thu rhino rho rid right rightmost rights rioyxlgt risk rlm rmd rmdir rmi rmiregistry
drda dbname mydb xdb syscs ruebezahl spell php doclet further hyt rnd rnfr rnto roadmap role roles roll rollback rolled rolls roman room root roots
pkcs genkey jks storepass dname keystore keystores keypass bugdatabase notation rot round rounded rounding roundmagic rounds row rowcount rowid rownum rows
oacute aacute egrave ntilde uuml eagrave eacute ouml ecirc ccedil icirc iacute uacute rowsize royalty rsa rsaquo rsquo rss rtrim ruby rubyforge ruebezahl rule rules
deferrability grantedrole granteetype pkcolumn fkcolumn temporarily cellpadding rnd run rund rundll runnable running runs runscript runtime rwd rws sabine safari
sqlexpress doctype colspan safe safely safety said salary sale sales salt salz sam same samp sample samples
ntilde mdash ensp radic szlig phi chi sube micro weierp loz bdquo zeta aelig rfloor notin empty le upsilon frac lang prop rho times rsquo uml nsub ni oslash crarr cup eth rang isin cong permil zwnj sdot iquest gamma diams sect acute macr ucirc amp ndash ge atilde forall oplus lowast image supe sim exist real sup dagger rceil nbsp emsp upsih pound lt ang quot ugrave beta int ordf otilde lsaquo yacute euml frac harr divide spades lfloor iuml ordm icirc para acirc curren reg rarr bull oacute zwj prime and cap uuml sbquo part agrave lsquo copy sigmaf laquo igrave iexcl euro thetasym ldquo thorn or clubs ccedil auml rsaquo uacute pi larr alpha aring yen mu equiv prod not ograve alefsym tau hearts yuml psi trade piv hellip iota thinsp lceil egrave cent ne xi lrm sub asymp cedil brvbar theta perp deg ecirc raquo sup omega frasl oline nu kappa omicron minus darr otimes aacute sum shy frac gt ocirc sup plusmn eacute delta eta nabla sup rlm middot ouml sigma epsilon rdquo lambda uarr iacute infin there sampling sans sat sata save saved savepoint savepoints saves saving say saying
schmorp alexander tort maurice oren oymaurice hazorea incompatibility timestampdiff says sbquo scalar scale scan scanned scanner scanners scanning scans schem schema
wordid indexid ignorelist ftl minutes partially causes supertable quantifieds across selectable schemas schemata schmorp school scm scope scott scratch screen screenshot script
deserialize referenceable tmjoin tmresume tmsuccess tmsuspend tmstartrscan xaer nota tmnoflags scripts scroll scrollable scrolling sdot search searchable searched searcher
synchronization xares inval tmonephase tmendrscan deserialization apos searches searching sec second secondary seconds secret sect section sections
queryframework operators cdd databaseaccess behaviour cddl parentheses extracter secure secureserv security see seed seeds seek seems select selectable selected
autocommit magyar recalculate indentation octype selecting selection selectivity selects self selfhtml sell selling send sending
upd testid dbid adam pipe pid xdo xsm xbl xby xts ffeecc xbo xcl xti xbi xda bohlen rawbyte sense sensitive sensitivity sent sentence sentinel sep sepang separate separated
gast abcdef injection rmi ldap rmiregistry bracket careful peek prev ucs bucher herkules ghi orld separately separator separators sept september seq sequence sequences sequential
rwd lck brack feb bel abcd xfc substituted substitution intra neg supplier gross datum prd pack lead rate accountid sequentially serial serializable serialization serialize serialized series serif
createtable unordered abcdefghijklmnop ffffff aeiou bdfghklmnpqrst wizbangblog server serverlist servers service services servicing servlet session sessions set
sets setters setting settings settlement setup sftp sha shall shallow share
### evaluatable evaluable shared shares shellbook shift shipping short shortcut shortest should shouldn
show showing shown shows shrink shrinking shuffle shut shutdown shutting shy sid
side sides sig sigma sigmaf sign signal signature signed signs signum silently
silly sim similar simon simple simpler simplest simplicity simplified simplifies
simplify simply simulate simulated sin since single singleton site sites
situation situations six sixty size sized sizes skill skip skipped slashdot sleep
sleeps slock slow slower slowest slows small smalldatetime smaller smallint smith
smpt snapshot snapshots snippets snoozesoft soap socket sockets software sold
solid solution solve solved solves some somebody somehow something sometime
sometimes soon sophisticated sorry sort sortable sorted sorting sorts sound
soundex sounds source sourceforge sources space spaces spacing spades spam span
spanish spans spantext spatial spec special specialized specially specific
specification specified specifies specify specifying specs speed spell spends
spent spi split spots spread sql sqlexpress sqlite sqlnulls sqlserver sqlstate
sqlxml sqrt square squirrelsql src ssl sss stable stack stage standalone standard
standardized stands stanford staring start started starter starting starts
startup starves stat state statement statements states static stating statistics
status statute stay stays stddev stddevp step steps steve still stmt stock stop
stoppage stopped stopping stops stor storage storages store stored storepass
stores storing str strange strategy stream streamcruncher streaming streams
street strength stress strict strictfp strictly string stringdecode stringencode
strings stringtoutf stritti strong stru struct structural structure structures
stub student students studios stuff style stylesheet stylesheets sub
subdirectories sube subject sublicense sublicenses submit subqueries subquery
subscribed subscriptions subsequent subsequently subset substance substitute
substituted substitution substr substring subtract subtraction subtree succeed
succeeds success successful successfully such suddenly sue sufficient
sufficiently suffix sugar suggest suggested suggestion suite suites sum summand
summary sun sunday sup supe super superficially superior superseded supertable
supplied supplier supply support supported supporters supporting supports
supposed sure surrogates surrounded survive susan suspend svn swap swapped swing
swiss switch switched switches switching switzerland sxd sync synchronization
synchronize synchronized synchronizing synchronously synonym syntax synth
synthetic sys syscs sysdate sysdba syst system systems systime systimestamp szlig
tab tablance table tableid tables tabs tag tags tahoma tail take taken takes tan
tanuki tanukisoftware tape tapes target targets task tasks tau tax tbalance tbody
tcp technical technology tell teller tellers telling temp template templated
temple temporarily temporary term terminal terminate terminated terminates
termination terms tertiary test testdb tested testid testing tests testtab text
textarea texts textual than thank thanks that the their them themselves then
theoretical theoretically theory there thereafter therefore thereof these theta
thetasym they thin thing things think thinsp third this thomas thorn those thread
threaded threading threads three threshold threw throttle throttling through
throw throwable throwing thrown throws thu ticker tid tidy time timeout times
timestamp timestampdiff timestamps timezone timezones timing tiny tinyblob
tinyint tinytext tired title titled tls tmendrscan tmfail tmjoin tmnoflags
tmonephase tmpl tmresume tmstartrscan tmsuccess tmsuspend today todo together
token tokenize tokenized tokenizer tokens tom tomcat too took tool toolbar tools
top topic topics toplink tort total totals tpc tpca tpcb tptp trace traces
tracing tracking trade trademark traditional trailing trans transaction
transactional transactions transfer transferred transform transient transitional
translatable translate translated translates translation translations
transmission transmitted transport tray tread treated tree trees trial trick
tried tries trig trigger triggered triggers trim trip true truncate truncated
truncates truncation trunk trx try trying tucker tune tuning tutorial twelve
twice two txt tymczak type typeof types typing typos uacute uarr ucase ucirc ucs
udp udts ugrave uid uml umlauts unaligned uncaught unclosed uncomment uncommitted
uncompressed undefined under underline underlined underlying understand
understands understood undetected undo undocumented undone unencrypted
unenforceable unescape unexpected unfortunately unicode uniform unindexed
uninstall uninstalling uninterruptible union unique uniqueness uniques unit
united units universal universally unix unknown unless unlink unlinked unlock
unmaintained unmodified unnamed unnecessarily unnecessary unneeded unordered
unquoted unrecoverable unrelated unsafe unscaled unset unsigned unsorted
unsuccessful unsupported untested until untranslated unusable unused unvisited
unwrap unwritten unzip upc upd updatable update updated updates updating upgrade
upload upon upper uppercase ups upsert upsih upsilon uri url urls usa usability
usage usb use used useful user username userpwd users uses using usual usually
utc utf util utility utilization utilize utils uui uuid uuml val valid validate
validation validity validly valuable value values van var varbinary varchar
variable variables variance variant various varp vector vendor verified versa
version versions vertical very veto vfat via vice view views violated violation
virtual virtuoso virus viruses visible visit visitor visualizer vldb void
volatile vpn vulnerability wait waiting waits walk walker want wants warehouse
warehouses warning warnings warranties warranty was washington watchdog watermark
way wayback ways weak web webclient webofweb webserver week weeks wegorkiewicz
weierp weight weights weird welcome well welt were what when whenever where
wherever whether which while whirlpool white whitespace who whole whom why wide
widely width wiki wikipedia wildcard wildcards will win window windows wiscorp
wish with withdraw withdrawn within without wizard wizbang wizbangblog wlam
wondering wood word wordid words work workaround workbench worked working works
world worry worst would wrap wrapper writable write writecache writer writers
writes writing written wrong www xads xaer xares xbi xbl xbo xby xcdsql xcl xda
xdb xdo xfc xid xlock xml xmlagg xmlattr xmlcdata xmlcomment xmlhttp xmlnode
xmlns xmlstartdoc xmltext xor xrunhprof xsm xtea xti xtime xts xvi xyz yacute
year yen yes yet yield yielding yjpagent ymd you your yourkit yourself ytd yuml
yyyy zeile zero zeros zeta zip zloty zone zwj zwnj
unavailable repeating sponsored indonesian yuliantoro joko indonesia unlike
### evaluatable > evaluable ### evaluatable > evaluable
Markdown 格式
0%
您添加了 0 到此讨论。请谨慎行事。
请先完成此评论的编辑!
注册 或者 后发表评论