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

--no commit message

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