Release Notes
1.2.1 (Apr 15, 2016)
1.2.0 (Nov 18, 2015)
- CB-10035 Updated
RELEASENOTES
to be newest to oldest
- CB-8549 Updated source to pass
Fortify
scan.
- Fixing contribute link.
- add
CSS class
to prompt div
for Windows platform
- CB-9347 - fix to allow to stack multiple
UIAlertControllers
1.1.1 (Jun 17, 2015)
- CB-9128 cordova-plugin-dialogs documentation translation: cordova-plugin-dialogs
- fix npm md
1.1.0 (May 06, 2015)
- CB-8928: Removed direct call to
toStaticHTML
, only call it if we are sure it's present. This closes #52
- CB-7734 -
navigator.notification.alert
or navigator.notification.confirm
seem have a "many words" issue. (closes #39)
1.0.0 (Apr 15, 2015)
- CB-8746 gave plugin major version bump
- CB-8683 updated wp and bb specific references of old id to new id
- CB-8683 changed plugin-id to pacakge-name
- CB-8653 properly updated translated docs to use new id
- CB-8653 updated translated docs to use new id
- Use TRAVIS_BUILD_DIR, install paramedic by npm
- CB-8653 Updated Readme
- CB-8659: ios: 4.0.x Compatibility: Remove use of deprecated headers
- CB-8565 Integrate TravisCI
- CB-8438 cordova-plugin-dialogs documentation translation: cordova-plugin-dialogs
- CB-8538 Added package.json file
- CB-8367 [org.apache.cordova.dialogs] Add Prompt support on Windows
0.3.0 (Feb 04, 2015)
- Correct way to specify Windows platform in config.xml
- CB-8351 ios: Use argumentForIndex rather than NSArray extension
- CB-7955 Add support "browser" platform
0.2.11 (Dec 02, 2014)
- CB-7737 lower min height for alert
- CB-8038 backslash getting escaped twice in BB10
- CB-8029 test 1-based indexing for confirm
- CB-7639 Update docs + manual tests
- CB-7639 Revert back
isAlertShowing
flag in case of exception to prevent queuing of future dialogs.
- CB-7639 Handle button labels as array on windows
- CB-7977 Mention
deviceready
in plugin docs
- Check for
setTextDirection
API level
- Android Make spinner dialog to use
THEME_DEVICE_DEFAULT_LIGHT
(same as the other dialogs)
- Android Unbreak
API
level < 14
- CB-7414 BB10 Document callback parameter for
navigator.notification.alert
- CB-7700 cordova-plugin-dialogs documentation translation: cordova-plugin-dialogs
- CB-7571 Bump version of nested plugin to match parent plugin
0.2.10 (Sep 17, 2014)
- CB-7538 Android beep thread fix Beep now executes in it's own thread. It was previously executing in the main UI thread which was causing the application to lock up will the beep was occurring. Closing pull request
- Set dialog text dir to locale
- Renamed test dir, added nested plugin.xml
- added documentation for manual tests
- CB-6965 Added manual tests
- CB-6965 Port notification tests to test-framework
0.2.9 (Aug 06, 2014)
- ubuntu: pass proper arguments to prompt callback
- ubuntu: use TextField instead of TextInput
- ubuntu: proper message escaping before passing to qml
- FFOS update notification.js
- CB-6127 Updated translations for docs
- android: Explicitly apply default theme to dialogs
- Fix Beep exception on Android when no argument passed
0.2.8 (Jun 05, 2014)
- CB-6801 Add license
- running original windows.open, inAppBrowser is overriding it no need to place CSS in every page anymore
- CB-5945 [Windows8] do not call success callbacks until dialog is dismissed
- CB-4616 Returned index 0 was not documented for notification.prompt
- update docs to state that prompt is supported on windowsphone
- CB-6528 allow scroll on alert message content
- [CB-6628][amazon-fireos]dialogs plugin's confirm and prompt methods dont work confirm() method was missing amazon-fireos platform check. added that. prompt() method had bug. It is executed in a worker thread that does not have a message queue(or Looper object) associated with it and hence "can't create a handler" exception is thrown. To fix this issue, we need to create the EditText widget from within the UI thread. This was fixed sometime ago when we added fireos platform but commit got lost somewhere. So fixing it again now.
- CB-6491 add CONTRIBUTING.md
- Added check for isFinishing() on the parent activity to prevent crashes when trying to display dialogs when activity is in this phase of it's lifecycle
- CB-4966 Dialogs are in window now No need to add anything to manifest or index.html
- Removing FirefoxOS Quirks no need to add special permission (it's different API with the same name) notification.css is added automatically
0.2.7 (Apr 17, 2014)
- CB-6212: [iOS] fix warnings compiled under arm64 64-bit
- CB-6411: [BlackBerry10] Work around Audio playback issue
- CB-6411: [BlackBerry10] Updates to beep
- CB-6422: [windows8] use cordova/exec/proxy
- CB-6460: Update license headers
- Add NOTICE file
0.2.6 (Feb 05, 2014)
- no need to recreate the manifest.webapp file after each
cordova prepare
for FFOS
- FFOS description added
0.2.5 (Jan 02, 2014)
- CB-4696 Fix compile error for Xcode 4.5.
- CB-5658 Add doc/index.md for Dialogs plugin
- CB-3762 Change prompt default to empty string
- Move images from css to img
0.2.4 (Dec 4, 2013)
- add ubuntu platform
- Added amazon-fireos platform. 2. Change to use amazon-fireos as a platform if user agent string contains 'cordova-amazon-fireos'.
- added beep funtionality using ms-winsoundevent:Notfication.Default
0.2.3 (Oct 28, 2013)
- CB-5128: added repo + issue tag to plugin.xml for dialogs plugin
- new plugin execute arguments supported
- new plugin style
- smaller fonts styling input
- img files copied inside plugin
- style added
- prompt added
- styling from James
- fixed "exec" calls addedd css, but not working yet
- first (blind) try
- CB-4915 Incremented plugin version on dev branch.
0.2.2 (Sept 25, 2013)
- CB-4889 bumping&resetting version
- [windows8] commandProxy was moved
- CB-4889 renaming reference in Notification.cs
- CB-4889 renaming org.apache.cordova.core.dialogs to org.apache.cordova.dialogs
- Rename CHANGELOG.md -> RELEASENOTES.md
- CB-4592 [Blackberry10] Added beep support
- CB-4752 Incremented plugin version on dev branch.


FOXPLOIT
Home
(current)
About
Contact
Login
Disabled
Our projects
Mobile App Developments
Web Developments
Machine Learning Developments
Search
First well


001package io.ebean; 002 003import javax.annotation.Nonnull; 004import javax.annotation.Nullable; 005import javax.persistence.NonUniqueResultException; 006import java.sql.Timestamp; 007import java.util.List; 008import java.util.Map; 009import java.util.Optional; 010import java.util.Set; 011import java.util.function.Consumer; 012import java.util.function.Predicate; 013 014/** 015 * Object relational query for finding a List, Set, Map or single entity bean. 016 *
 017 * Example: Create the query using the API. 018 *
 019 *
 020 *
{@code 021 * 022 * List<Order> orderList = DB.find(Order.class) 023 * .where() 024 * .like("customer.name","rob%") 025 * .gt("orderDate",lastWeek) 026 * .orderBy("customer.id, id desc") 027 * .setMaxRows(50) 028 * .findList(); 029 * 030 * ... 031 * }
 032 *
 033 * Example: The same query using the query language 034 *
 035 *
{@code 036 * 037 * String oql = 038 * +" where customer.name like :custName and orderDate > :minOrderDate " 039 * +" order by customer.id, id desc " 040 * +" limit 50 "; 041 * 042 * List<Order> orderList = DB.createQuery(Order.class, oql) 043 * .setParameter("custName", "Rob%") 044 * .setParameter("minOrderDate", lastWeek) 045 * .findList(); 046 * ... 047 * }
 048 *
AutoTune
 049 *
 050 * Ebean has built in support for "AutoTune". This is a mechanism where a query 051 * can be automatically tuned based on profiling information that is collected. 052 *
 053 *
 054 * This is effectively the same as automatically using select() and fetch() to 055 * build a query that will fetch all the data required by the application and no 056 * more. 057 *
 058 *
 059 * It is expected that AutoTune will be the default approach for many queries 060 * in a system. It is possibly not as useful where the result of a query is sent 061 * to a remote client or where there is some requirement for "Read Consistency" 062 * guarantees. 063 *
 064 *
Query Language
 065 *
 066 * Partial Objects 067 *
 068 *
 069 * The find and fetch clauses support specifying a list of 070 * properties to fetch. This results in objects that are "partially populated". 071 * If you try to get a property that was not populated a "lazy loading" query 072 * will automatically fire and load the rest of the properties of the bean (This 073 * is very similar behaviour as a reference object being "lazy loaded"). 074 *
 075 *
 076 * Partial objects can be saved just like fully populated objects. If you do 077 * this you should remember to include the "Version" property in the 078 * initial fetch. If you do not include a version property then optimistic 079 * concurrency checking will occur but only include the fetched properties. 080 * Refer to "ALL Properties/Columns" mode of Optimistic Concurrency checking. 081 *
 082 *
{@code 083 * [ select [ ( * | {fetch properties} ) ] ] 084 * [ fetch {path} [ ( * | {fetch properties} ) ] ] 085 * [ where {predicates} ] 086 * [ order by {order by properties} ] 087 * [ limit {max rows} [ offset {first row} ] ] 088 * }
 089 *
 090 * SELECT [ ( * | {fetch properties} ) ] 091 *
 092 *
 093 * With the select you can specify a list of properties to fetch. 094 *
 095 *
 096 * FETCH {path} [ ( * | {fetch properties} ) ] 097 *
 098 *
 099 * With the fetch you specify the associated property to fetch and populate. The 100 * path is a OneToOne, ManyToOne, OneToMany or ManyToMany property. 101 *
 102 *
 103 * For fetch of a path we can optionally specify a list of properties to fetch. 104 * If you do not specify a list of properties ALL the properties for that bean 105 * type are fetched. 106 *
 107 *
 108 * WHERE {list of predicates} 109 *
 110 *
 111 * The list of predicates which are joined by AND OR NOT ( and ). They can 112 * include named (or positioned) bind parameters. These parameters will need to 113 * be bound by {@link Query#setParameter(String, Object)}. 114 *
 115 *
 116 * ORDER BY {order by properties} 117 *
 118 *
 119 * The list of properties to order the result. You can include ASC (ascending) 120 * and DESC (descending) in the order by clause. 121 *
 122 *
 123 * LIMIT {max rows} [ OFFSET {first row} ] 124 *
 125 *
 126 * The limit offset specifies the max rows and first row to fetch. The offset is 127 * optional. 128 *
 129 *
Examples of Ebean's Query Language
 130 *
 131 * Find orders fetching its id, shipDate and status properties. Note that the id 132 * property is always fetched even if it is not included in the list of fetch 133 * properties. 134 *
 135 *
{@code 136 * 137 * select (shipDate, status) 138 * 139 * }
 140 *
 141 * Find orders with a named bind variable (that will need to be bound via 142 * {@link Query#setParameter(String, Object)}). 143 *
 144 *
{@code 145 * 146 * where customer.name like :custLike 147 * 148 * }
 149 *
 150 * Find orders and also fetch the customer with a named bind parameter. This 151 * will fetch and populate both the order and customer objects. 152 *
 153 *
{@code 154 * 155 * fetch customer 156 * where customer.id = :custId 157 * 158 * }
 159 *
 160 * Find orders and also fetch the customer, customer shippingAddress, order 161 * details and related product. Note that customer and product objects will be 162 * "Partial Objects" with only some of their properties populated. The customer 163 * objects will have their id, name and shipping address populated. The product 164 * objects (associated with each order detail) will have their id, sku and name 165 * populated. 166 *
 167 *
{@code 168 * 169 * fetch customer (name) 170 * fetch customer.shippingAddress 171 * fetch details 172 * fetch details.product (sku, name) 173 * 174 * }
 175 * 176 * @param <T> the type of Entity bean this query will fetch. 177 */ 178public interface Query<T> { 179 180 /** 181 * For update mode. 182 */ 183 enum ForUpdate { 184 /** 185 * Standard For update clause. 186 */ 187 BASE, 188 189 /** 190 * For update with No Wait option. 191 */ 192 NOWAIT, 193 194 /** 195 * For update with Skip Locked option. 196 */ 197 SKIPLOCKED 198 } 199 200 /** 201 * Set RawSql to use for this query. 202 */ 203 Query<T> setRawSql(RawSql rawSql); 204 205 /** 206 * Perform an 'As of' query using history tables to return the object graph 207 * as of a time in the past. 208 *
 209 * To perform this query the DB must have underlying history tables. 210 *
 211 * 212 * @param asOf the date time in the past at which you want to view the data 213 */ 214 Query<T> asOf(Timestamp asOf); 215 216 /** 217 * Execute the query against the draft set of tables. 218 */ 219 Query<T> asDraft(); 220 221 /** 222 * Convert the query to a DTO bean query. 223 *
 224 * We effectively use the underlying ORM query to build the SQL and then execute 225 * and map it into DTO beans. 226 */ 227 <D> DtoQuery<D> asDto(Class<D> dtoClass); 228 229 /** 230 * Convert the query to a UpdateQuery. 231 *
 232 * Typically this is used with query beans to covert a query bean 233 * query into an UpdateQuery like the examples below. 234 *
 235 * 236 *
{@code 237 * 238 * int rowsUpdated = new QCustomer() 239 * .name.startsWith("Rob") 240 * .asUpdate() 241 * .set("active", false) 242 * .update();; 243 * 244 * }
 245 * 246 *
{@code 247 * 248 * int rowsUpdated = new QContact() 249 * .notes.note.startsWith("Make Inactive") 250 *<EMAIL_ADDRESS>251 * .customer.id.equalTo(42) 252 * .asUpdate() 253 * .set("inactive", true) 254 * .setRaw("email = lower(email)") 255 * .update(); 256 * 257 * }
 258 */ 259 UpdateQuery<T> asUpdate(); 260 261 /** 262 * Cancel the query execution if supported by the underlying database and 263 * driver. 264 *
 265 * This must be called from a different thread to the query executor. 266 *
 267 */ 268 void cancel(); 269 270 /** 271 * Return a copy of the query. 272 *
 273 * This is so that you can use a Query as a "prototype" for creating other 274 * query instances. You could create a Query with various where expressions 275 * and use that as a "prototype" - using this copy() method to create a new 276 * instance that you can then add other expressions then execute. 277 *
 278 */ 279 Query<T> copy(); 280 281 /** 282 * Specify the PersistenceContextScope to use for this query. 283 *
 284 * When this is not set the 'default' configured on {@link io.ebean.config.ServerConfig#setPersistenceContextScope(PersistenceContextScope)} 285 * is used - this value defaults to {@link PersistenceContextScope#TRANSACTION}. 286 *
 287 * Note that the same persistence Context is used for subsequent lazy loading and query join queries. 288 *
 289 * Note that #findEach uses a 'per object graph' PersistenceContext so this scope is ignored for 290 * queries executed as #findIterate, #findEach, #findEachWhile. 291 * 292 * @param scope The scope to use for this query and subsequent lazy loading. 293 */ 294 Query<T> setPersistenceContextScope(PersistenceContextScope scope); 295 296 /** 297 * Set the index(es) to search for a document store which uses partitions. 298 *
 299 * For example, when executing a query against ElasticSearch with daily indexes we can 300 * explicitly specify the indexes to search against. 301 *
 302 *
{@code 303 * 304 * // explicitly specify the indexes to search 305 * query.setDocIndexName("logstash-2016.11.5,logstash-2016.11.6") 306 * 307 * // search today's index 308 * query.setDocIndexName("$today") 309 * 310 * // search the last 3 days 311 * query.setDocIndexName("$last-3") 312 * 313 * }
 314 *
 315 * If the indexName is specified with ${daily} e.g. "logstash-${daily}" ... then we can use 316 * $today and $last-x as the search docIndexName like the examples below. 317 *
 318 *
{@code 319 * 320 * // search today's index 321 * query.setDocIndexName("$today") 322 * 323 * // search the last 3 days 324 * query.setDocIndexName("$last-3") 325 * 326 * }
 327 * 328 * @param indexName The index or indexes to search against 329 * @return This query 330 */ 331 Query<T> setDocIndexName(String indexName); 332 333 /** 334 * Return the ExpressionFactory used by this query. 335 */ 336 ExpressionFactory getExpressionFactory(); 337 338 /** 339 * Returns true if this query was tuned by autoTune. 340 */ 341 boolean isAutoTuned(); 342 343 /** 344 * Explicitly specify whether to use AutoTune for this query. 345 *
 346 * If you do not call this method on a query the "Implicit AutoTune mode" is 347 * used to determine if AutoTune should be used for a given query. 348 *
 349 *
 350 * AutoTune can add additional fetch paths to the query and specify which 351 * properties are included for each path. If you have explicitly defined some 352 * fetch paths AutoTune will not remove them. 353 *
 354 */ 355 Query<T> setAutoTune(boolean autoTune); 356 357 /** 358 * Execute the query allowing properties with invalid JSON to be collected and not fail the query. 359 *
{@code 360 * 361 * // fetch a bean with JSON content 362 * EBasicJsonList bean= DB.find(EBasicJsonList.class) 363 * .setId(42) 364 * .setAllowLoadErrors() // collect errors into bean state if we have invalid JSON 365 * .findOne(); 366 * 367 * 368 * // get the invalid JSON errors from the bean state 369 * Map<String, Exception> errors = server().getBeanState(bean).getLoadErrors(); 370 * 371 * // If this map is not empty tell we have invalid JSON 372 * // and should try and fix the JSON content or inform the user 373 * 374 * }
 375 */ 376 Query<T> setAllowLoadErrors(); 377 378 /** 379 * Set the default lazy loading batch size to use. 380 *
 381 * When lazy loading is invoked on beans loaded by this query then this sets the 382 * batch size used to load those beans. 383 * 384 * @param lazyLoadBatchSize the number of beans to lazy load in a single batch 385 */ 386 Query<T> setLazyLoadBatchSize(int lazyLoadBatchSize); 387 388 /** 389 * Execute the query including soft deleted rows. 390 *
 391 * This means that Ebean will not add any predicates to the query for filtering out 392 * soft deleted rows. You can still add your own predicates for the deleted properties 393 * and effectively you have full control over the query to include or exclude soft deleted 394 * rows as needed for a given use case. 395 *
 396 */ 397 Query<T> setIncludeSoftDeletes(); 398 399 /** 400 * Disable read auditing for this query. 401 *
 402 * This is intended to be used when the query is not a user initiated query and instead 403 * part of the internal processing in an application to load a cache or document store etc. 404 * In these cases we don't want the query to be part of read auditing. 405 *
 406 */ 407 Query<T> setDisableReadAuditing(); 408 409 /** 410 * Specify the properties to fetch on the root level entity bean in comma delimited format. 411 *
 412 * The Id property is automatically included in the properties to fetch unless setDistinct(true) 413 * is set on the query. 414 *
 415 *
 416 * Use {@link #fetch(String, String)} to specify specific properties to fetch 417 * on other non-root level paths of the object graph. 418 *
 419 *
{@code 420 * 421 * List<Customer> customers = DB.find(Customer.class) 422 * // Only fetch the customer id, name and status. 423 * // This is described as a "Partial Object" 424 * .select("name, status") 425 * .where.ilike("name", "rob%") 426 * .findList(); 427 * 428 * }
 429 * 430 * @param fetchProperties the properties to fetch for this bean (* = all properties). 431 */ 432 Query<T> select(String fetchProperties); 433 434 /** 435 * Apply the fetchGroup which defines what part of the object graph to load. 436 */ 437 Query<T> select(FetchGroup<T> fetchGroup); 438 439 /** 440 * Specify a path to fetch eagerly including specific properties. 441 *
 442 * Ebean will endeavour to fetch this path using a SQL join. If Ebean determines that it can 443 * not use a SQL join (due to maxRows or because it would result in a cartesian product) Ebean 444 * will automatically convert this fetch query into a "query join" - i.e. use fetchQuery(). 445 *
 446 *
{@code 447 * 448 * // query orders... 449 * List<Order> orders = DB.find(Order.class) 450 * // fetch the customer... 451 * // ... getting the customers name and phone number 452 * .fetch("customer", "name, phoneNumber") 453 * 454 * // ... also fetch the customers billing address (* = all properties) 455 * .fetch("customer.billingAddress", "*") 456 * .findList(); 457 * }
 458 *
 459 * If columns is null or "*" then all columns/properties for that path are fetched. 460 *
 461 *
{@code 462 * 463 * // fetch customers (their id, name and status) 464 * List<Customer> customers = DB.find(Customer.class) 465 * .select("name, status") 466 * .fetch("contacts", "firstName,lastName,email") 467 * .findList(); 468 * 469 * }
 470 * 471 * @param path the property path we wish to fetch eagerly. 472 * @param fetchProperties properties of the associated bean that you want to include in the 473 * fetch (* means all properties, null also means all properties). 474 */ 475 Query<T> fetch(String path, String fetchProperties); 476 477 /** 478 * Fetch the path and properties using a "query join" (separate SQL query). 479 *
 480 * This is the same as: 481 *
 482 *
{@code 483 * 484 * fetch(path, fetchProperties, new FetchConfig().query()) 485 * 486 * }
 487 *
 488 * This would be used instead of a fetch() when we use a separate SQL query to fetch this 489 * part of the object graph rather than a SQL join. 490 *
 491 *
 492 * We might typically get a performance benefit when the path to fetch is a OneToMany 493 * or ManyToMany, the 'width' of the 'root bean' is wide and the cardinality of the many 494 * is high. 495 *
 496 * 497 * @param path the property path we wish to fetch eagerly. 498 * @param fetchProperties properties of the associated bean that you want to include in the 499 * fetch (* means all properties, null also means all properties). 500 */ 501 Query<T> fetchQuery(String path, String fetchProperties); 502 503 /** 504 * Fetch the path and properties lazily (via batch lazy loading). 505 *
 506 * This is the same as: 507 *
 508 *
{@code 509 * 510 * fetch(path, fetchProperties, new FetchConfig().lazy()) 511 * 512 * }
 513 *
 514 * The reason for using fetchLazy() is to either: 515 *
 516 *
 517 *
Control/tune what is fetched as part of lazy loading
 518 *
Make use of the L2 cache, build this part of the graph from L2 cache
 519 *
 520 * 521 * @param path the property path we wish to fetch lazily. 522 * @param fetchProperties properties of the associated bean that you want to include in the 523 * fetch (* means all properties, null also means all properties). 524 */ 525 Query<T> fetchLazy(String path, String fetchProperties); 526 527 /** 528 * Additionally specify a FetchConfig to use a separate query or lazy loading 529 * to load this path. 530 *
{@code 531 * 532 * // fetch customers (their id, name and status) 533 * List<Customer> customers = DB.find(Customer.class) 534 * .select("name, status") 535 * .fetch("contacts", "firstName,lastName,email", new FetchConfig().lazy(10)) 536 * .findList(); 537 * 538 * }
 539 * 540 * @param path the property path we wish to fetch eagerly. 541 */ 542 Query<T> fetch(String path, String fetchProperties, FetchConfig fetchConfig); 543 544 /** 545 * Specify a path to fetch eagerly including all its properties. 546 *
 547 * Ebean will endeavour to fetch this path using a SQL join. If Ebean determines that it can 548 * not use a SQL join (due to maxRows or because it would result in a cartesian product) Ebean 549 * will automatically convert this fetch query into a "query join" - i.e. use fetchQuery(). 550 *
 551 *
{@code 552 * 553 * // fetch customers (their id, name and status) 554 * List<Customer> customers = DB.find(Customer.class) 555 * // eager fetch the contacts 556 * .fetch("contacts") 557 * .findList(); 558 * 559 * }
 560 * 561 * @param path the property path we wish to fetch eagerly. 562 */ 563 Query<T> fetch(String path); 564 565 /** 566 * Fetch the path eagerly using a "query join" (separate SQL query). 567 *
 568 * This is the same as: 569 *
 570 *
{@code 571 * 572 * fetch(path, new FetchConfig().query()) 573 * 574 * }
 575 *
 576 * This would be used instead of a fetch() when we use a separate SQL query to fetch this 577 * part of the object graph rather than a SQL join. 578 *
 579 *
 580 * We might typically get a performance benefit when the path to fetch is a OneToMany 581 * or ManyToMany, the 'width' of the 'root bean' is wide and the cardinality of the many 582 * is high. 583 *
 584 * 585 * @param path the property path we wish to fetch eagerly 586 */ 587 Query<T> fetchQuery(String path); 588 589 /** 590 * Fetch the path lazily (via batch lazy loading). 591 *
 592 * This is the same as: 593 *
 594 *
{@code 595 * 596 * fetch(path, new FetchConfig().lazy()) 597 * 598 * }
 599 *
 600 * The reason for using fetchLazy() is to either: 601 *
 602 *
 603 *
Control/tune what is fetched as part of lazy loading
 604 *
Make use of the L2 cache, build this part of the graph from L2 cache
 605 *
 606 * 607 * @param path the property path we wish to fetch lazily. 608 */ 609 Query<T> fetchLazy(String path); 610 611 /** 612 * Additionally specify a JoinConfig to specify a "query join" and or define 613 * the lazy loading query. 614 *
{@code 615 * 616 * // fetch customers (their id, name and status) 617 * List<Customer> customers = DB.find(Customer.class) 618 * // lazy fetch contacts with a batch size of 100 619 * .fetch("contacts", new FetchConfig().lazy(100)) 620 * .findList(); 621 * 622 * }
 623 */ 624 Query<T> fetch(String path, FetchConfig fetchConfig); 625 626 /** 627 * Apply the path properties replacing the select and fetch clauses. 628 *
 629 * This is typically used when the FetchPath is applied to both the query and the JSON output. 630 *
 631 */ 632 Query<T> apply(FetchPath fetchPath); 633 634 /** 635 * Execute the query returning the list of Id's. 636 *
 637 * This query will execute against the EbeanServer that was used to create it. 638 *
 639 */ 640 @Nonnull 641  List findIds(); 642 643 /** 644 * Execute the query iterating over the results. 645 *
 646 * Note that findIterate (and findEach and findEachWhile) uses a "per graph" 647 * persistence context scope and adjusts jdbc fetch buffer size for large 648 * queries. As such it is better to use findList for small queries. 649 *
 650 *
 651 * Remember that with {@link QueryIterator} you must call {@link QueryIterator#close()} 652 * when you have finished iterating the results (typically in a finally block). 653 *
 654 *
 655 * findEach() and findEachWhile() are preferred to findIterate() as they ensure 656 * the jdbc statement and resultSet are closed at the end of the iteration. 657 *
 658 *
 659 * This query will execute against the EbeanServer that was used to create it. 660 *
 661 *
{@code 662 * 663 * Query<Customer> query = DB.find(Customer.class) 664 * .where().eq("status", Status.NEW) 665 * .order().asc("id"); 666 * 667 * // use try with resources to ensure QueryIterator is closed 668 * 669 * try (QueryIterator<Customer> it = query.findIterate()) { 670 * while (it.hasNext()) { 671 * Customer customer = it.next(); 672 * // do something with customer ... 673 * } 674 * } 675 * 676 * }
 677 */ 678 @Nonnull 679 QueryIterator<T> findIterate(); 680 681 /** 682 * Execute the query processing the beans one at a time. 683 *
 684 * This method is appropriate to process very large query results as the 685 * beans are consumed one at a time and do not need to be held in memory 686 * (unlike #findList #findSet etc) 687 *
 688 *
 689 * Note that findEach (and findEachWhile and findIterate) uses a "per graph" 690 * persistence context scope and adjusts jdbc fetch buffer size for large 691 * queries. As such it is better to use findList for small queries. 692 *
 693 *
 694 * Note that internally Ebean can inform the JDBC driver that it is expecting larger 695 * resultSet and specifically for MySQL this hint is required to stop it's JDBC driver 696 * from buffering the entire resultSet. As such, for smaller resultSets findList() is 697 * generally preferable. 698 *
 699 *
 700 * Compared with #findEachWhile this will always process all the beans where as 701 * #findEachWhile provides a way to stop processing the query result early before 702 * all the beans have been read. 703 *
 704 *
 705 * This method is functionally equivalent to findIterate() but instead of using an 706 * iterator uses the Consumer interface which is better suited to use with Java8 closures. 707 *
 708 *
{@code 709 * 710 * DB.find(Customer.class) 711 * .where().eq("status", Status.NEW) 712 * .order().asc("id") 713 * .findEach((Customer customer) -> { 714 * 715 * // do something with customer 716 * System.out.println("-- visit " + customer); 717 * }); 718 * 719 * }
 720 * 721 * @param consumer the consumer used to process the queried beans. 722 */ 723 void findEach(Consumer<T> consumer); 724 725 /** 726 * Execute the query using callbacks to a visitor to process the resulting 727 * beans one at a time. 728 *
 729 * Note that findEachWhile (and findEach and findIterate) uses a "per graph" 730 * persistence context scope and adjusts jdbc fetch buffer size for large 731 * queries. As such it is better to use findList for small queries. 732 *
 733 *
 734 * This method is functionally equivalent to findIterate() but instead of using an 735 * iterator uses the Predicate (SAM) interface which is better suited to use with Java8 closures. 736 *
 737 *
{@code 738 * 739 * DB.find(Customer.class) 740 * .fetch("contacts", new FetchConfig().query(2)) 741 * .where().eq("status", Status.NEW) 742 * .order().asc("id") 743 * .setMaxRows(2000) 744 * .findEachWhile((Customer customer) -> { 745 * 746 * // do something with customer 747 * System.out.println("-- visit " + customer); 748 * 749 * // return true to continue processing or false to stop 750 * return (customer.getId() < 40); 751 * }); 752 * 753 * }
 754 * 755 * @param consumer the consumer used to process the queried beans. 756 */ 757 void findEachWhile(Predicate<T> consumer); 758 759 /** 760 * Execute the query returning the list of objects. 761 *
 762 * This query will execute against the EbeanServer that was used to create it. 763 *
 764 *
{@code 765 * 766 * List<Customer> customers = DB.find(Customer.class) 767 * .where().ilike("name", "rob%") 768 * .findList(); 769 * 770 * }
 771 */ 772 @Nonnull 773 List<T> findList(); 774 775 /** 776 * Execute the query returning the set of objects. 777 *
 778 * This query will execute against the EbeanServer that was used to create it. 779 *
 780 *
{@code 781 * 782 * Set<Customer> customers = DB.find(Customer.class) 783 * .where().ilike("name", "rob%") 784 * .findSet(); 785 * 786 * }
 787 */ 788 @Nonnull 789 Set<T> findSet(); 790 791 /** 792 * Execute the query returning a map of the objects. 793 *
 794 * This query will execute against the EbeanServer that was used to create it. 795 *
 796 *
 797 * You can use setMapKey() so specify the property values to be used as keys 798 * on the map. If one is not specified then the id property is used. 799 *
 800 *
{@code 801 * 802 * Map<String, Product> map = DB.find(Product.class) 803 * .setMapKey("sku") 804 * .findMap(); 805 * 806 * }
 807 */ 808 @Nonnull 809 <K> Map<K, T> findMap(); 810 811 /** 812 * Execute the query returning a list of values for a single property. 813 *
 814 *
Example 1:
 815 *
{@code 816 * 817 * List<String> names = 818 * DB.find(Customer.class) 819 * .select("name") 820 * .orderBy().asc("name") 821 * .findSingleAttributeList(); 822 * 823 * }
 824 *
 825 *
Example 2:
 826 *
{@code 827 * 828 * List<String> names = 829 * DB.find(Customer.class) 830 * .setDistinct(true) 831 * .select("name") 832 * .where().eq("status", Customer.Status.NEW) 833 * .orderBy().asc("name") 834 * .setMaxRows(100) 835 * .findSingleAttributeList(); 836 * 837 * }
 838 * 839 * @return the list of values for the selected property 840 */ 841 @Nonnull 842  List findSingleAttributeList(); 843 844 /** 845 * Execute a query returning a single value of a single property/column. 846 *
 847 *
{@code 848 * 849 * String name = 850 * DB.find(Customer.class) 851 * .select("name") 852 * .where().eq("id", 42) 853 * .findSingleAttribute(); 854 * 855 * }
 856 */ 857  A findSingleAttribute(); 858 859 /** 860 * Return true if this is countDistinct query. 861 */ 862 boolean isCountDistinct(); 863 864 /** 865 * Execute the query returning true if a row is found. 866 *
 867 * The query is executed using max rows of 1 and will only select the id property. 868 * This method is really just a convenient way to optimise a query to perform a 869 * 'does a row exist in the db' check. 870 *
 871 * 872 *
Example using a query bean:
 873 *
{@code 874 * 875 * boolean userExists = 876 * new QContact() 877 *<EMAIL_ADDRESS>878 * .exists(); 879 * 880 * }
 881 * 882 *
Example:
 883 *
{@code 884 * 885 * boolean userExists = query() 886 * .where().eq("email"<EMAIL_ADDRESS>887 * .exists(); 888 * 889 * }
 890 * 891 * @return True if the query finds a matching row in the database 892 */ 893 boolean exists(); 894 895 /** 896 * Execute the query returning either a single bean or null (if no matching 897 * bean is found). 898 *
 899 * If more than 1 row is found for this query then a NonUniqueResultException is 900 * thrown. 901 *
 902 *
 903 * This is useful when your predicates dictate that your query should only 904 * return 0 or 1 results. 905 *
 906 *
{@code 907 * 908 * // assuming the sku of products is unique... 909 * Product product = DB.find(Product.class) 910 * .where().eq("sku", "aa113") 911 * .findOne(); 912 * ... 913 * }
 914 *
 915 * It is also useful with finding objects by their id when you want to specify 916 * further join information. 917 *
 918 *
{@code 919 * 920 * // Fetch order 1 and additionally fetch join its order details... 921 * Order order = DB.find(Order.class) 922 * .setId(1) 923 * .fetch("details") 924 * .findOne(); 925 * 926 * // the order details were eagerly loaded 927 * List<OrderDetail> details = order.getDetails(); 928 * ... 929 * }
 930 * 931 * @throws NonUniqueResultException if more than one result was found 932 */ 933 @Nullable 934 T findOne(); 935 936 /** 937 * Execute the query returning an optional bean. 938 */ 939 @Nonnull 940 Optional<T> findOneOrEmpty(); 941 942 /** 943 * Return versions of a @History entity bean. 944 *
 945 * Note that this query will work against view based history implementations 946 * but not sql2011 standards based implementations that require a start and 947 * end timestamp to be specified. 948 *
 949 *
 950 * Generally this query is expected to be a find by id or unique predicates query. 951 * It will execute the query against the history returning the versions of the bean. 952 *
 953 */ 954 @Nonnull 955 List<Version<T>> findVersions(); 956 957 /** 958 * Return versions of a @History entity bean between the 2 timestamps. 959 *
 960 * Generally this query is expected to be a find by id or unique predicates query. 961 * It will execute the query against the history returning the versions of the bean. 962 *
 963 */ 964 @Nonnull 965 List<Version<T>> findVersionsBetween(Timestamp start, Timestamp end); 966 967 /** 968 * Execute as a delete query deleting the 'root level' beans that match the predicates 969 * in the query. 970 *
 971 * Note that if the query includes joins then the generated delete statement may not be 972 * optimal depending on the database platform. 973 *
 974 * 975 * @return the number of beans/rows that were deleted. 976 */ 977 int delete(); 978 979 /** 980 * Execute as a delete query returning the number of rows deleted using the given transaction. 981 *
 982 * Note that if the query includes joins then the generated delete statement may not be 983 * optimal depending on the database platform. 984 *
 985 * 986 * @return the number of beans/rows that were deleted. 987 */ 988 int delete(Transaction transaction); 989 990 /** 991 * Execute the UpdateQuery returning the number of rows updated. 992 * 993 * @return the number of beans/rows updated. 994 */ 995 int update(); 996 997 /** 998 * Execute the UpdateQuery returning the number of rows updated using the given transaction. 999 * 1000 * @return the number of beans/rows updated. 1001 */ 1002 int update(Transaction transaction); 1003 1004 /** 1005 * Return the count of entities this query should return. 1006 *
 1007 * This is the number of 'top level' or 'root level' entities. 1008 *
 1009 */ 1010 int findCount(); 1011 1012 /** 1013 * Execute find row count query in a background thread. 1014 *
 1015 * This returns a Future object which can be used to cancel, check the 1016 * execution status (isDone etc) and get the value (with or without a 1017 * timeout). 1018 *
 1019 * 1020 * @return a Future object for the row count query 1021 */ 1022 @Nonnull 1023 FutureRowCount<T> findFutureCount(); 1024 1025 /** 1026 * Execute find Id's query in a background thread. 1027 *
 1028 * This returns a Future object which can be used to cancel, check the 1029 * execution status (isDone etc) and get the value (with or without a 1030 * timeout). 1031 *
 1032 * 1033 * @return a Future object for the list of Id's 1034 */ 1035 @Nonnull 1036 FutureIds<T> findFutureIds(); 1037 1038 /** 1039 * Execute find list query in a background thread. 1040 *
 1041 * This query will execute in it's own PersistenceContext and using its own transaction. 1042 * What that means is that it will not share any bean instances with other queries. 1043 *
 1044 * 1045 * @return a Future object for the list result of the query 1046 */ 1047 @Nonnull 1048 FutureList<T> findFutureList(); 1049 1050 /** 1051 * Return a PagedList for this query using firstRow and maxRows. 1052 *
 1053 * The benefit of using this over findList() is that it provides functionality to get the 1054 * total row count etc. 1055 *
 1056 *
 1057 * If maxRows is not set on the query prior to calling findPagedList() then a 1058 * PersistenceException is thrown. 1059 *
 1060 *
{@code 1061 * 1062 * PagedList<Order> pagedList = DB.find(Order.class) 1063 * .setFirstRow(50) 1064 * .setMaxRows(20) 1065 * .findPagedList(); 1066 * 1067 * // fetch the total row count in the background 1068 * pagedList.loadRowCount(); 1069 * 1070 * List<Order> orders = pagedList.getList(); 1071 * int totalRowCount = pagedList.getTotalRowCount(); 1072 * 1073 * }
 1074 * 1075 * @return The PagedList 1076 */ 1077 @Nonnull 1078 PagedList<T> findPagedList(); 1079 1080 /** 1081 * Set a named bind parameter. Named parameters have a colon to prefix the name. 1082 *
{@code 1083 * 1084 * // a query with a named parameter 1085 * String oql = "find order where status = :orderStatus"; 1086 * 1087 * List<Order> list = DB.find(Order.class, oql) 1088 * .setParameter("orderStatus", OrderStatus.NEW) 1089 * .findList(); 1090 * 1091 * }
 1092 * 1093 * @param name the parameter name 1094 * @param value the parameter value 1095 */ 1096 Query<T> setParameter(String name, Object value); 1097 1098 /** 1099 * Set an ordered bind parameter according to its position. Note that the 1100 * position starts at 1 to be consistent with JDBC PreparedStatement. You need 1101 * to set a parameter value for each ? you have in the query. 1102 *
{@code 1103 * 1104 * // a query with a positioned parameter 1105 * String oql = "where status = ? order by id desc"; 1106 * 1107 * List<Order> list = DB.createQuery(Order.class, oql) 1108 * .setParameter(1, OrderStatus.NEW) 1109 * .findList(); 1110 * 1111 * }
 1112 * 1113 * @param position the parameter bind position starting from 1 (not 0) 1114 * @param value the parameter bind value. 1115 */ 1116 Query<T> setParameter(int position, Object value); 1117 1118 /** 1119 * Set the Id value to query. This is used with findOne(). 1120 *
 1121 * You can use this to have further control over the query. For example adding 1122 * fetch joins. 1123 *
 1124 *
{@code 1125 * 1126 * Order order = DB.find(Order.class) 1127 * .setId(1) 1128 * .fetch("details") 1129 * .findOne(); 1130 * 1131 * // the order details were eagerly fetched 1132 * List<OrderDetail> details = order.getDetails(); 1133 * 1134 * }
 1135 */ 1136 Query<T> setId(Object id); 1137 1138 /** 1139 * Return the Id value. 1140 */ 1141 Object getId(); 1142 1143 /** 1144 * Add a single Expression to the where clause returning the query. 1145 *
{@code 1146 * 1147 * List<Order> newOrders = DB.find(Order.class) 1148 * .where().eq("status", Order.NEW) 1149 * .findList(); 1150 * ... 1151 * 1152 * }
 1153 */ 1154 Query<T> where(Expression expression); 1155 1156 /** 1157 * Add Expressions to the where clause with the ability to chain on the 1158 * ExpressionList. You can use this for adding multiple expressions to the 1159 * where clause. 1160 *
{@code 1161 * 1162 * List<Order> orders = DB.find(Order.class) 1163 * .where() 1164 * .eq("status", Order.NEW) 1165 * .ilike("customer.name","rob%") 1166 * .findList(); 1167 * 1168 * }
 1169 * 1170 * @return The ExpressionList for adding expressions to. 1171 * @see Expr 1172 */ 1173 ExpressionList<T> where(); 1174 1175 /** 1176 * Add Full text search expressions for Document store queries. 1177 *
 1178 * This is currently ElasticSearch only and provides the full text 1179 * expressions such as Match and Multi-Match. 1180 *
 1181 *
 1182 * This automatically makes this query a "Doc Store" query and will execute 1183 * against the document store (ElasticSearch). 1184 *
 1185 *
 1186 * Expressions added here are added to the "query" section of an ElasticSearch 1187 * query rather than the "filter" section. 1188 *
 1189 *
 1190 * Expressions added to the where() are added to the "filter" section of an 1191 * ElasticSearch query. 1192 *
 1193 */ 1194 ExpressionList<T> text(); 1195 1196 /** 1197 * This applies a filter on the 'many' property list rather than the root 1198 * level objects. 1199 *
 1200 * Typically you will use this in a scenario where the cardinality is high on 1201 * the 'many' property you wish to join to. Say you want to fetch customers 1202 * and their associated orders... but instead of getting all the orders for 1203 * each customer you only want to get the new orders they placed since last 1204 * week. In this case you can use filterMany() to filter the orders. 1205 *
 1206 *
{@code 1207 * 1208 * List<Customer> list = DB.find(Customer.class) 1209 * .fetch("orders") 1210 * .where().ilike("name", "rob%") 1211 * .filterMany("orders").eq("status", Order.Status.NEW).gt("orderDate", lastWeek) 1212 * .findList(); 1213 * 1214 * }
 1215 *
 1216 * Please note you have to be careful that you add expressions to the correct 1217 * expression list - as there is one for the 'root level' and one for each 1218 * filterMany that you have. 1219 *
 1220 * 1221 * @param propertyName the name of the many property that you want to have a filter on. 1222 * @return the expression list that you add filter expressions for the many to. 1223 */ 1224 ExpressionList<T> filterMany(String propertyName); 1225 1226 /** 1227 * Add Expressions to the Having clause return the ExpressionList. 1228 *
 1229 * Currently only beans based on raw sql will use the having clause. 1230 *
 1231 *
 1232 * Note that this returns the ExpressionList (so you can add multiple 1233 * expressions to the query in a fluent API way). 1234 *
 1235 * 1236 * @return The ExpressionList for adding more expressions to. 1237 * @see Expr 1238 */ 1239 ExpressionList<T> having(); 1240 1241 /** 1242 * Add an expression to the having clause returning the query. 1243 *
 1244 * Currently only beans based on raw sql will use the having clause. 1245 *
 1246 *
 1247 * This is similar to {@link #having()} except it returns the query rather 1248 * than the ExpressionList. This is useful when you want to further specify 1249 * something on the query. 1250 *
 1251 * 1252 * @param addExpressionToHaving the expression to add to the having clause. 1253 * @return the Query object 1254 */ 1255 Query<T> having(Expression addExpressionToHaving); 1256 1257 /** 1258 * Set the order by clause replacing the existing order by clause if there is 1259 * one. 1260 *
 1261 * This follows SQL syntax using commas between each property with the 1262 * optional asc and desc keywords representing ascending and descending order 1263 * respectively. 1264 *
 1265 *
 1266 * This is EXACTLY the same as {@link #order(String)}. 1267 *
 1268 */ 1269 Query<T> orderBy(String orderByClause); 1270 1271 /** 1272 * Set the order by clause replacing the existing order by clause if there is 1273 * one. 1274 *
 1275 * This follows SQL syntax using commas between each property with the 1276 * optional asc and desc keywords representing ascending and descending order 1277 * respectively. 1278 *
 1279 *
 1280 * This is EXACTLY the same as {@link #orderBy(String)}. 1281 *
 1282 */ 1283 Query<T> order(String orderByClause); 1284 1285 /** 1286 * Return the OrderBy so that you can append an ascending or descending 1287 * property to the order by clause. 1288 *
 1289 * This will never return a null. If no order by clause exists then an 'empty' 1290 * OrderBy object is returned. 1291 *
 1292 *
 1293 * This is EXACTLY the same as {@link #orderBy()}. 1294 *
 1295 */ 1296 OrderBy<T> order(); 1297 1298 /** 1299 * Return the OrderBy so that you can append an ascending or descending 1300 * property to the order by clause. 1301 *
 1302 * This will never return a null. If no order by clause exists then an 'empty' 1303 * OrderBy object is returned. 1304 *
 1305 *
 1306 * This is EXACTLY the same as {@link #order()}. 1307 *
 1308 */ 1309 OrderBy<T> orderBy(); 1310 1311 /** 1312 * Set an OrderBy object to replace any existing OrderBy clause. 1313 *
 1314 * This is EXACTLY the same as {@link #setOrderBy(OrderBy)}. 1315 *
 1316 */ 1317 Query<T> setOrder(OrderBy<T> orderBy); 1318 1319 /** 1320 * Set an OrderBy object to replace any existing OrderBy clause. 1321 *
 1322 * This is EXACTLY the same as {@link #setOrder(OrderBy)}. 1323 *
 1324 */ 1325 Query<T> setOrderBy(OrderBy<T> orderBy); 1326 1327 /** 1328 * Set whether this query uses DISTINCT. 1329 *
 1330 * The select() clause MUST be specified when setDistinct(true) is set. The reason for this is that 1331 * generally ORM queries include the "id" property and this doesn't make sense for distinct queries. 1332 *
 1333 *
{@code 1334 * 1335 * List<Customer> customers = 1336 * DB.find(Customer.class) 1337 * .setDistinct(true) 1338 * .select("name") 1339 * .findList(); 1340 * 1341 * }
 1342 */ 1343 Query<T> setDistinct(boolean isDistinct); 1344 1345 /** 1346 * Extended version for setDistinct in conjunction with "findSingleAttributeList"; 1347 * 1348 *
{@code 1349 * 1350 * List<CountedValue<Order.Status>> orderStatusCount = 1351 * 1352 * DB.find(Order.class) 1353 * .select("status") 1354 * .where() 1355 * .gt("orderDate", LocalDate.now().minusMonths(3)) 1356 * 1357 * // fetch as single attribute with a COUNT 1358 * .setCountDistinct(CountDistinctOrder.COUNT_DESC_ATTR_ASC) 1359 * .findSingleAttributeList(); 1360 * 1361 * for (CountedValue<Order.Status> entry : orderStatusCount) { 1362 * System.out.println(" count:" + entry.getCount()+" orderStatus:" + entry.getValue() ); 1363 * } 1364 * 1365 * // produces 1366 * 1367 * count:3 orderStatus:NEW 1368 * count:1 orderStatus:SHIPPED 1369 * count:1 orderStatus:COMPLETE 1370 * 1371 * }
 1372 */ 1373 Query<T> setCountDistinct(CountDistinctOrder orderBy); 1374 1375 /** 1376 * Return the first row value. 1377 */ 1378 int getFirstRow(); 1379 1380 /** 1381 * Set the first row to return for this query. 1382 * 1383 * @param firstRow the first row to include in the query result. 1384 */ 1385 Query<T> setFirstRow(int firstRow); 1386 1387 /** 1388 * Return the max rows for this query. 1389 */ 1390 int getMaxRows(); 1391 1392 /** 1393 * Set the maximum number of rows to return in the query. 1394 * 1395 * @param maxRows the maximum number of rows to return in the query. 1396 */ 1397 Query<T> setMaxRows(int maxRows); 1398 1399 /** 1400 * Set the property to use as keys for a map. 1401 *
 1402 * If no property is set then the id property is used. 1403 *
 1404 *
{@code 1405 * 1406 * // Assuming sku is unique for products... 1407 * 1408 * Map<String,Product> productMap = DB.find(Product.class) 1409 * .setMapKey("sku") // sku map keys... 1410 * .findMap(); 1411 * 1412 * }
 1413 * 1414 * @param mapKey the property to use as keys for a map. 1415 */ 1416 Query<T> setMapKey(String mapKey); 1417 1418 /** 1419 * Set this to false to not use the bean cache. 1420 *
 1421 * This method is now superseded by {@link #setBeanCacheMode(CacheMode)} 1422 * which provides more explicit options controlled bean cache use. 1423 *
 1424 *
 1425 * This method is likely to be deprecated in the future with migration 1426 * over to setUseBeanCache(). 1427 *
 1428 */ 1429 default Query<T> setUseCache(boolean useCache) { 1430 return setBeanCacheMode(useCache ? CacheMode.ON : CacheMode.OFF); 1431 } 1432 1433 /** 1434 * Set the mode to use the bean cache when executing this query. 1435 *
 1436 * By default "find by id" and "find by natural key" will use the bean cache 1437 * when bean caching is enabled. Setting this to false means that the query 1438 * will not use the bean cache and instead hit the database. 1439 *
 1440 *
 1441 * By default findList() with natural keys will not use the bean cache. In that 1442 * case we need to explicitly use the bean cache. 1443 *
 1444 */ 1445 Query<T> setBeanCacheMode(CacheMode beanCacheMode); 1446 1447 /** 1448 * Set the {@link CacheMode} to use the query for executing this query. 1449 */ 1450 Query<T> setUseQueryCache(CacheMode queryCacheMode); 1451 1452 /** 1453 * Calls {@link #setUseQueryCache(CacheMode)} with ON or OFF. 1454 */ 1455 default Query<T> setUseQueryCache(boolean enabled) { 1456 return setUseQueryCache(enabled ? CacheMode.ON : CacheMode.OFF); 1457 } 1458 1459 /** 1460 * Set an id to identify this query for profiling purposes. 1461 *
 1462 * The profileId is expected to be unique for a given bean type. 1463 *
 1464 *
 1465 * Note that the profileId is treated as a short internally and has a MAX value of 32,767. 1466 *
 1467 */ 1468 Query<T> setProfileId(int profileId); 1469 1470 /** 1471 * Set the profile location of this query. This is used to relate query execution metrics 1472 * back to a location like a specific line of code. 1473 */ 1474 Query<T> setProfileLocation(ProfileLocation profileLocation); 1475 1476 /** 1477 * Set a label on the query. 1478 *
 1479 * This label can be used to help identify query performance metrics but we can also use 1480 * profile location enhancement on Finders so for some that would be a better option. 1481 *
 1482 */ 1483 Query<T> setLabel(String label); 1484 1485 /** 1486 * Set to true if this query should execute against the doc store. 1487 *
 1488 * When setting this you may also consider disabling lazy loading. 1489 *
 1490 */ 1491 Query<T> setUseDocStore(boolean useDocStore); 1492 1493 /** 1494 * When set to true when you want the returned beans to be read only. 1495 */ 1496 Query<T> setReadOnly(boolean readOnly); 1497 1498 /** 1499 * Will be deprecated - migrate to use setBeanCacheMode(CacheMode.RECACHE). 1500 *
 1501 * When set to true all the beans from this query are loaded into the bean cache. 1502 */ 1503 Query<T> setLoadBeanCache(boolean loadBeanCache); 1504 1505 /** 1506 * Set a timeout on this query. 1507 *
 1508 * This will typically result in a call to setQueryTimeout() on a 1509 * preparedStatement. If the timeout occurs an exception will be thrown - this 1510 * will be a SQLException wrapped up in a PersistenceException. 1511 *
 1512 * 1513 * @param secs the query timeout limit in seconds. Zero means there is no limit. 1514 */ 1515 Query<T> setTimeout(int secs); 1516 1517 /** 1518 * A hint which for JDBC translates to the Statement.fetchSize(). 1519 *
 1520 * Gives the JDBC driver a hint as to the number of rows that should be 1521 * fetched from the database when more rows are needed for ResultSet. 1522 *
 1523 *
 1524 * Note that internally findEach and findEachWhile will set the fetch size 1525 * if it has not already as these queries expect to process a lot of rows. 1526 * If we didn't then Postgres and MySql for example would eagerly pull back 1527 * all the row data and potentially consume a lot of memory in the process. 1528 *
 1529 *
 1530 * As findEach and findEachWhile automatically set the fetch size we don't have 1531 * to do so generally but we might still wish to for tuning a specific use case. 1532 *
 1533 */ 1534 Query<T> setBufferFetchSizeHint(int fetchSize); 1535 1536 /** 1537 * Return the sql that was generated for executing this query. 1538 *
 1539 * This is only available after the query has been executed and provided only 1540 * for informational purposes. 1541 *
 1542 */ 1543 String getGeneratedSql(); 1544 1545 /** 1546 * Execute using "for update" clause which results in the DB locking the record. 1547 */ 1548 Query<T> forUpdate(); 1549 1550 /** 1551 * Execute using "for update" clause with "no wait" option. 1552 *
 1553 * This is typically a Postgres and Oracle only option at this stage. 1554 *
 1555 */ 1556 Query<T> forUpdateNoWait(); 1557 1558 /** 1559 * Execute using "for update" clause with "skip locked" option. 1560 *
 1561 * This is typically a Postgres and Oracle only option at this stage. 1562 *
 1563 */ 1564 Query<T> forUpdateSkipLocked(); 1565 1566 /** 1567 * Return true if this query has forUpdate set. 1568 */ 1569 boolean isForUpdate(); 1570 1571 /** 1572 * Return the "for update" mode to use. 1573 */ 1574 ForUpdate getForUpdateMode(); 1575 1576 /** 1577 * Set root table alias. 1578 */ 1579 Query<T> alias(String alias); 1580 1581 /** 1582 * Set the base table to use for this query. 1583 *
 1584 * Typically this is used when a table has partitioning and we wish to specify a specific 1585 * partition/table to query against. 1586 *
 1587 *
{@code 1588 * 1589 * QOrder() 1590 * .setBaseTable("order_2019_05") 1591 * .status.equalTo(Status.NEW) 1592 * .findList(); 1593 * 1594 * }
 1595 */ 1596 Query<T> setBaseTable(String baseTable); 1597 1598 /** 1599 * Return the type of beans being queried. 1600 */ 1601 Class<T> getBeanType(); 1602 1603 /** 1604 * Restrict the query to only return subtypes of the given inherit type. 1605 * 1606 *
{@code 1607 * 1608 * List<Animal> animals = 1609 * new QAnimal() 1610 * .name.startsWith("Fluffy") 1611 * .setInheritType(Cat.class) 1612 * .findList(); 1613 * 1614 * }
 1615 * 1616 * @param type An inheritance subtype of the 1617 */ 1618 Query<T> setInheritType(Class<? extends T> type); 1619 1620 /** 1621 * Returns the inherit type. This is normally the same as getBeanType() returns as long as no other type is set. 1622 */ 1623 Class<? extends T> getInheritType(); 1624 1625 /** 1626 * Return the type of query being executed. 1627 */ 1628 QueryType getQueryType(); 1629 1630 /** 1631 * Set true if you want to disable lazy loading. 1632 *
 1633 * That is, once the object graph is returned further lazy loading is disabled. 1634 *
 1635 */ 1636 Query<T> setDisableLazyLoading(boolean disableLazyLoading); 1637 1638 /** 1639 * Returns the set of properties or paths that are unknown (do not map to known properties or paths). 1640 *
 1641 * Validate the query checking the where and orderBy expression paths to confirm if 1642 * they represent valid properties or paths for the given bean type. 1643 *
 1644 */ 1645 Set<String> validate(); 1646 1647 /** 1648 * Controls, if paginated queries should always append an 'order by id' statement at the end to 1649 * guarantee a deterministic sort result. This may affect performance. 1650 * If this is not enabled, and an orderBy is set on the query, it's up to the programmer that 1651 * this query provides a deterministic result. 1652 */ 1653 Query<T> orderById(boolean orderById); 1654 1655}


Trump: Bolivia events boost democracy, send signal to Venezuela, Nicaragua
WASHINGTON (Reuters) - U.S. President Donald Trump on Monday said the resignation of Evo Morales as Bolivia’s president preserves democracy in that country and sends a signal to “illegitimate regimes” in Venezuela and Nicaragua.
“The resignation yesterday of Bolivian President Evo Morales is a significant moment for democracy in the Western Hemisphere,” Trump said in a statement. “These events send a strong signal to the illegitimate regimes in Venezuela and Nicaragua that democracy and the will of the people will always prevail.”


Phylogenetics methods: tree exploration
Erick Matsen
Subtree prune regraft
Typical cycle for a ML program
- Start with quick heuristic tree (e.g. parsimony, distance-based).
- Try all local tree modifications; optimize branch lengths for each.
- If we found something better, return to 2. Otherwise stop.
Tree traversal
See jupyter notebook


The concept classes are used to simplify NodeImpl. More...
Classes | |
| struct | NoAttribute |
| struct | SingleAttribute |
| struct | MultiAttribute |
| struct | NameIndexConcept |
| struct | NameIndexConcept< MultiAttribute< std::string > > |
The concept classes are used to simplify NodeImpl.
Since different types of avro types carry different attributes, such as names, or field names for record members. Using the concept class of NoAttribute vs Attribute, the NodeImpl object can enable/disable the attribute, but the code is the same in either case.
Furthermore, attributes may have different types, for example, most attributes are strings, but fixed types have a size attribute, which is integer.
Since compound types are composed of other types, the leaf attribute concepts extend a NodeImpl to include leaf nodes, and attributes for leaf nodes, which are used to build parse trees.


Leave feedback:
Send!
Add text to database
Title:
Body text:
Tags (separated by space):
Send data
Add image to database
Add tags to image (separated by space):
Send img


shapeR aims to simplify GIS mapping by giving access through simple R functions to maps from different sources.
The list of available maps is shown in the following table:
| Regions | Sources |
|---|---|
| World | https://www.naturalearthdata.com/ |
| Countries | https://gadm.org/download_world.html |
You can install the current development version of ‘shapeR’ with:
install.packages("devtools") devtools::install_github("warint/shapeR")
A user needs to enter the ISO code of a country. To have access to this code, the following function provides this information.
shaper_country() # A list of all countries will be produced shaper_country(country = "Canada") # The ISO code for Canada will be produced shaper_country("Canada") # The ISO code for Canada will be produced
Users can visualize which level is available for the choosen country here: https://gadm.org/download_country_v3.html
The level goes from 1 to 5, with 0 being the country level. You can access the metadata here: https://gadm.org/metadata.html
Be aware that not all countries have the five levels of granularity.
Once the user knows the ISO code and the wanted level, s.he can collect the data in a very easy way through this function:
shaper_data(country_code = "CAN") # The shapefile for Canada with level 0 (the default) will be produced shaper_data(country_code = "CAN", level = 3) # The shapefile for Canada with level 3 will be produced shaper_data("CAN", 3) # The shapefile for Canada with level 3 will be produced


We are splitting the caligraphic path of the stroke into various quads ... Here's a simple hand coded example made of three stroke parts


A CAPPUCCINO is an Italian coffee drink that is traditionally prepared with double espresso, and steamed milk foam. Variations of the drink involve the use of cream instead of milk, and flavoring with cinnamon or chocolate powder
Ristretto
RISTRETTO is traditionally a short shot of espresso coffee made with the normal amount of ground coffee but extracted with about half the amount of water
Flat Whire
A FLAT WHITE is an espresso-based coffee beverage. The beverage is prepared by pouring microfoam over a single or double shot of espresso.
Caffe Mocha
A CAFFE MOCHA, also called mocaccino, is a chocolate-flavored variant of a caffè latte. Other commonly used spellings are mochaccino and also mochachino.


Screenshot
Image Size
In this example, we specify the width and height of an image with the width and height attributes:


FAQs
_What is BMI?
BMI is an acronym for Body Mass Index, and it is an indicator of the amount of fat which is stored in the human body. It provides a measure of the appropriateness of your weight to your height, based on health issues which are known to arise as a result of having a BMI which is too low or too high.
_Who invented BMI?
The BMI formula and its name were invented by different people, living in different centuries. The BMI formula was developed in the 1830s by Adolphe Quetelet, a Belgian mathematician and social statistician. He used his skills in calculus and statistics to analyse the relationship between height and weight in populations, and formulated what was known for 140 years as the Quetelet Index. In 1972 the American biologist and physiologist Ancel Keys published a paper endorsing the validity of the index, and in the process he renamed it and popularised it as the Body Mass Index.
_Why is BMI important?
BMI is important as it is able to predict, with considerable accuracy, mortality and morbidity rates in populations. What this means is that BMI is not only able to predict the rates at which people within a given population or group will die and suffer disease, but it is able to predict the incidence of the different types of diseases which occur in the population and which cause those deaths. However, as Adolphe Quetelet and Ancel Keys stressed, BMI's predictive abilities apply to populations only, and not to individuals within it.
_How is BMI calculated?
BMI is calculated using only the variables of weight and height. Your BMI is equal to your weight in kilograms divided by your height in metres squared. You can also calculate your BMI using imperial units, in which case your BMI is equal to your weight in pounds divided by your height in inches squared, multiplied by 703.
_When should BMI be used?
The calculation of BMI can be used for males and non-pregnant females between the ages of 18 and 65. Although BMI is calculated for children in exactly the same way as for adults, the results are used in an entirely different way and for that reason a standard BMI calculator should not be used for those under the age of 18. Also, the physiology of elderly people differs from other adults (due to factors such as muscle wasting and height reduction), and consequently BMI calculations should not be made for that group. BMI calculations are also unsuitable for those who have developed significant amounts of muscle mass through physical exercise, as the results will tend to indicate higher levels of body fat than is actually the case.
_What are the major BMI classifications?
- BMI values less than 18.5 kg/m² are considered underweight.
- BMI values from 18.5 kg/m² to 24.9 kg/m² are healthy.
- Overweight is defined as a body mass index of 25.0 to less than 30.0 kg/m².
- Obesity is defined as a BMI of 30.0 kg/m² or greater.
- Extreme obesity is defined as a BMI of 40 kg/m² or greater.


Texans edge Colts for top spot in AFC South
by OmnisportThe Houston Texans claimed sole possession of first place in the NFL's AFC South with a 20-17 victory over the Indianapolis Colts.
Deshaun Watson and DeAndre Hopkins starred as the Texans (7-4) moved clear in the AFC South on Thursday.
Texans quarterback Watson threw two touchdown passes to Hopkins and finished with 298 yards against the Colts (6-5).
The Texans, who were humbled 41-7 by the Baltimore Ravens last week, trailed by four points early in the fourth quarter in Houston.
But the Texans rallied – Hopkins stretching out for a 30-yard reception as Houston moved 20-17 ahead of Indianapolis.
Houston's defence then stepped up and stopped the Colts on fourth-and-seven with three minutes remaining.
There was some late controversy 50 seconds from the end, when Watson ran the ball and had it punched out.
The Colts appealed for the recovered fumble but there was no review and the Texans kept the ball, eventually running out the clock.
After the game, the NFL said, "there was no clear visual evidence of a recovery by the defence".
Colts quarterback Jacoby Brissett was 16 of 25 for 129 yards, while he rushed for a touchdown.


Finds a set of specimens by using one or several parameters
Fill in one or several fields.
Reduce selection by starting at the top of each block, clicking on preset alternatives at each level. Or enter text directly into boxes.
Exact match of entire text is usually needed for a hit, but in the fields “Collector”, “Original taxon” and “Original text”, words (one or several) are matched.
Fields marked * will not be used in the search.


This is the header
This is some stuff I don't want
This is some stuff I want, but it should be rendered as display: none
This is some stuff
This is some stuff I don't want, delete it
This is some stuff I want, but it should be rendered as display: none
This is the article.
Nav item 1
Nav item 2
Nav item 1
Nav item 2
How the above should read:


{% extends 'brambling/user/__base.html' %} {% load floppyforms %} {% block title %}Saved Attendees – {{ block.super }}{% endblock %} {% block javascripts %} {{ block.super }} {% endblock %} {% block main %} {{ block.super }}
{% if attendees %} Here are attendee details stored with your account. You can prefill forms with these details when registering for events. {% else %} Currently you don’t have any attendee details stored with your account. {% endif %}
Save details here for anyone you might regularly register for events. These might include yourself, family, and significant others.


Brew Keeper is a tool for home brewers. You can track your brew, bottle, and chill dates and also take notes on your brewing experiences.
This web site was built by Sean Normoyle and is free to use. Please create a GitHub issue for any questions, bug reports, or other feedback.


My favorite old PC games
I still have nothing useful to share with you guys, but I have some free time now. So I'd like to tell you about some things from the past. These games were my first and not as popular as StarCraft, Doom, or Quake, but I enjoyed playing them nonetheless. Good times.
Tom and Jerry
Since my dad gave me his old PC (IBM 80386) as a gift I spent lots of time playing this game. I a six years old at that time and the game was so difficult! I couldn't pass even the first level. There was like nowhere to go. After a while, I realized that I could switch my weapons and use a balloon to make my character fly. After that level 1 became an easy win.
The second level was way harder. It was all about jumping from one cliff to the other. I hated those cliffs because I was falling down all the time, and each fall set me almost to the beginning.
After many trials I managed to complete level 2, but then got completely stuck at level 3. Third level was insanely hard. So, I gave up.
Color Lines
This game was actually my dad's favorite. He played it all the time. Then, my mom also started playing it, so I couldn't resist. By the way, Color Lines had the best music intro I have ever heard.
The gameplay itself seemed easy, but the game required lots of thinking, almost like chess.
My father was constantly making the best score. He was always the king. So my mom and I could not get even close to his score. It was like a family game. One of us were sitting there playing and others just walking around giving some hints and suggestions about the best moves. Hated when my mom teached me how to play. :)
Moorhuhn Series
After my dad upgraded my PC, giving me his old one again (this time it was Pentium 100), this chicken shooter series became the new best game for me and my mom.
I played it most of the time. Dad never played this because the game didn't require any thinking at all. Just shoot some chicks - that's all.
He just brought us the CD with all the series: Moorhuhn JAGD, Moorhuhn 2 and Moorhuhn Winter Edition. Each game had different graphics, landscapes, decorations, bonuses and soundtracks. As for the gameplay it was basically the same in all three parts. Sometimes I got bored by that, but kept playing from time to time anyway.
Then I got Worms and Warcraft 2 and the real life became something I lost for many years.


Require this file if you need Unicode support. Tips for improvement - esp. ruby 1.9: www.ruby-forum.com/topic/184730
Required Files
- cucumber/platform
- cucumber/formatter/ansicolor
- iconv
Classes and Modules
- MODULE Cucumber
Constants
| CODEPAGE | = | ENV['CUCUMBER_OUTPUT_ENCODING'] |
| CODEPAGE | = | 'UTF-8' |
| CODEPAGE | = | "cp#{$1.to_i}" |
| CODEPAGE | = | "cp1252" |


This page talks about my experiences in customer service I received while I was working at Dunkin Donuts and Subway.
Dunkin', also known as Dunkin' Donuts, which is an American multinational coffee and doughnut company. It was founded by William Rosenberg in Quincy, Massachusetts, in 1950. With approximately 12,900 locations in 42 countries, Dunkin' is one of the largest coffee shop and donut shop chains in the world. Its products include donuts, bagels, coffee, and Munchkins donut holes.
Subway is also known as Doctor's Associates Inc. It is an American fast food restaurant franchise that primarily sells submarine sandwiches (subs), salads and beverages. It is one of the fastest-growing franchises in the world and, as of October 2019, had 41,512 locations in more than 100 countries. More than half its locations are in the United States.


-
Aco: ACO manufactures a range of drainage and landscape products from polymer concrete, stainless steel, mild steel, cast iron, fiberglass, and molded plastics.
-
Advanced Drainage Systems: corrugated polyethylene pipe for subsurface drainage.
-
All Spec Enclosures: Steel and Mesh Enclosures.
-
Ames Company: Ames produces valves and fittings for fire protection, irrigation and waterworks.
-
APCO Williamette: APCO Clean Water Air Release Valves (ARV)
-
AVK: American AVK manufactures a complete line of high quality gate valves, fire hydrants, check valves, and accessories.
-
A.Y. McDonald: A.Y. McDonald Mfg. Co. is a manufacturer Waterworks Brass, Plumbing Valves, Pumps and Water Systems and High Pressure Gas Valves and Meter Bars.
-
Bermad: Hydraulic Control Valves.
-
Calpico: Pipe Linx, Casing Insulators, Flange Insulations Kits, Pipe Identification Markers, Cut Flange Gaskets, Valve Identification Tags, Adhesive Pipe Wrapping Tape, Locater and Tracer Tape, Wall Sleeves, Manhole Adapter Seals, Anodes, Cathodic Protection.
-
Cambribge-Lee Reading Tube: Copper tubing for plumbing, HVAC & Refrigeration
-
Cherne Industries: Pnuematic and Mechanical Plugs.
-
Cla-Val Company: Automatic Control Valves
-
Clow Company: Hydrants, Gate Valves, Butterfly Valves, Check Valves
-
Coleman Cable: Manufacturer of wire, cable and other electircal products.
-
Crispin: Air Realease Valves, Check Valves, Butterfly Vales and Plug Valves.
-
Custom Fab: Ductile Iron Pipe, Concrete Pressure Pipe, Welded Steel Pipe, Restrained Joint Pipe, Gaskets, and Fittings.
-
DeZURIK: Air Realease Valves, Check Valves, Butterfly Vales, Plug Valves, Control Valves, Actuators, Ball and Cone Valves
-
Diamond Plastics: PVC Pipe for water, sewer and irrigation.
-
EBAA Iron Sales: Pipe Restraints and Flexible Expansion Joints.
-
Etco Specialty Products: PVC Plugs
-
Febco: Single & Double Check Detector Valves, Vacuum Breakers, Pressure Reducing Valves, Strainers.
-
Fernco: Flexible Couplings, Shielded Couplings and O-Rings.
-
Ford Meter Box: Service Brass, Repair Clamps, Cast Coulings and Fabricated Steel.
-
Fortune Valve: Ball Valves, Pressure Valves, Gate Valves, Globe Valves and Check Valves.
-
Garlock: Gaskets, Seals, Pump Diaphrams, Expansion Joint and Butterfly Valves.
-
GPK Products Inc.: PVC Fittings.
-
Hot Box: Drain Systems and Enclosures
-
Ideal Tridon: Clamps.
-
Infact: Mechanical Joint Restraints.
-
Integrity Fusion: Molded Butt Fusion Fittings, Electrofusion Fittings, Poly Ball Valves and Transition Fittings.
-
James JonesHydrants, Corp Valves, Bronze Saddles, Service Fittings, Meter Valves, Curb Valves, Meter Setters and yokes.
-
JCM Industries: Pipe Repair, connection and branching fittings.
-
Jet Swet: Plumbing tools
-
JM Eagle: PVC and PE pipe for water, sewer, irragation, drainage and gas.
-
Keckley: Ball Valves, Check Valves, Gate Valves, Control Valves, Strainers and pump accessories.
-
Kupferle Foundry Company: Hydrants, blow-offs and sampling stations.
-
Lee Brass: Threaded brass fittings.
-
Lift-All: Slings, tie down assemblies and specialty straps.
-
Master Meter Inc.: Water Meters
-
Matco Norca: Valves, steel fittings, brass fittings, copper fittings, PVC & CPVC fittings, steel nipples and brass nipples
-
Milwaukee Valve: Ball valves, gate valves, globe valves, check valves and butterfly valves.
-
Mission Clay: Clay pipe and fittings.
-
Mission RubberRubber coulings and fittings.
-
Mueller Company: Hydrants, service brass, repair clamps, service saddles, tapping sleeves, couplings, fire protection, gate valves, butterfly vlaves and check valves.
-
Multi Fittings: PVC fittings for water and sewer.
-
Napac: Mechanical joints, flange fittings, hydrants, valves and couplings.
-
NDS: Drainage systems, valve boxes, meter boxes and flow management.
-
Nibco: Bronze and copper fittings, PVC fittings and CPVC fittings,
-
North American Pipe Corp.: PVC Pipe
-
Oldcastle Precast: Catch basins, manholes, vaults, area drains and grade rings.
-
Plastic TrendsPVC fittings
-
Plumbest: Valves and fittings
-
Prinsco: Corrugated pipe, chambers and fittings.
-
Potter Roemer: Fire protection equipment.
-
Power Seal: Steel sleeves, clamps, couplings and saddles.
-
Red Valve: Tideflex check valves, pinch valve sleeves, air operated pinch valves, knife gate valves and expansion joints
-
Red-White Valve: Ball valves, gate valves, globe valves, check valves, butterfly valves.
-
ReliableCheck valves and risers.
-
Rigid: Tools.
-
Romac Industries Inc.: Coupling, repair clamps, service saddles, tapping sleeves and restraints.
-
Sigma: Steel fittings, restraints,
-
SIP Industries: Manhole rings and covers, frames/grates, valve & service boxes, ductile iron fittings and ez grip joint restraints.
-
Smith-Blair Inc.: Joint restraints, repair clamps, couplings, adapter and saddles. Tapping sleeves.
-
Smith Cooper: Valves, iron fittings and nipples, carbon steel fittings and nipples, stainless steel fittings and nipples, stainless pipe, brass pipe, brass fittings and nipples.
-
South Bay Foundry: Manhole frames and covers, meter boxes, steel frames and grates, iron frames and grates, pipe fittings.
-
Spears Manufacturing: PVC Fittings.
-
Star Pipe: Utility fittings, joint restraints, grooved couplings and adapters, manhole rings and covers, valve and meter boxes
-
T. Chrsty Enterprise: Polywrap, PVC cements, sealants, marking tape, paint, tools.
-
Total Piping Solutions: products for pipe tapping, repair and joining
-
Tripac: bolt, nut, gasket and flange insulation kits, link seals, casing spacers, wall sleeves, wedge anchors, pipe-supports, struts, post bases.
-
Trumbull: Tools
-
Tyler Pipe Company: cast iron soil pipe, fittings, couplings and gaskets for DWV systems.
-
Tyler Union: Ductile iron fittings, restraints, valve boxes, gaskets, glands and bolts.
-
Underground Solutions Inc.: Fusible PVC, ServiceGuard Composite pipe, TerraBrute CR pipe.
-
U.S. Pipe: Ductile Iron Pipe, Concrete Pressure Pipe, Welded Steel Pipe, Restrained Joint Pipe, Gaskets, and Fittings along with other products for the water and wastewater industries.
-
Valmatic: Air valves, check valves, butterfly valves and plug valves.
-
Vinyltech Corp: PVC pipe.
-
Watts: Backflows, drainage systems and control valves.

-
Zoeller: Pumps
-
Zurn Company: Drainage systems.


jQuery Component
Shim
repository
for the
jQuery
.
Package Managers
Bower
:
jquery
Component
:
components/jquery
Composer
:
components/jquery
spm
:
jquery


(Second) Biographical Sketch
of Patrick
Donnelly
Source: A HISTORY OF HEMPSTEAD COUNTY by Dolphus
Whitten Jr., in 1940 as taken from ARKANSAS STATE GAZETTEER describing the
town of Hope in 1888:
"A prosperous incorporated town of nearly 2000 . . .
. First settled in
1873 . . . .
"Among the
pioneer citizens of Hope were George McClanahan, the contractor who had charge
of building the railroad right of way through Hope, and Patrick Donnelly, a
member of the construction crew. While
the railroad tracks were being laid across the prairie, Donnelly learned that
some of the land along the route was owned by the government. Realizing that this property would be very
valuable, he borrowed a wagon and team from McClanahan and made an overnight
trip to Camden, where the homestead office was located. The next day he returned with a claim to
eighty acres, including a part of what became the business center of Hope. No one knows how or why Mr. Donnelly lost out,
but he suddenly pulled up stakes and went north, a comparatively
"broke" man as he sold his furniture, except one article, a dresser
which he left with a friend."
Source: Letter from Mary Nell Turner of the
Hempstead County Historical Society, 1998
"Patrick Donnelly is a 'legend' in our early Hope
history. He gave the building and got
the Catholic Church started here . . . .
He sold a lot in Hope for a rick of wood . . . such being his generous
nature. He supposedly left here broke.
Provided by Betty Latta Kitchen
-- e-mail: Betty Kitchen
Click here for the Short-Cut Table of Contents


Sound Test
Guess the Game
Reticulating Splines...
Can You Guess this Game?
Let's A Go!
Need help?
Ask Clippy
Want a different game?
Reset
Tell others that you like this
Twitter
Facebook


What follows is a table:
Here be some vars
variable types
Example
int
1
double
1.0
float
char
'a'
null


Collection time must not be more than a year in the past.
Collection time must not be more than a year in the future.
Your group is responsible for observations about the land, water and air.
This includes weather, any recent rainfall, tide and current, as well as environmental conditions of the land and the water, pollution, and garbage.
Wind speed must be a positive number.
Humidity must be a positive number.
Water condition image is required.
Surface current speed must be a positive number.
Record the extent of each type of garbage in the water.
Give more information about the marked Combined Sewer Overflow (CSO) pipes.
Give more information about the unmarked or other outfall pipes.
Land condition image is required.
Estimate percent surface cover for the adjacent shoreline (about 500 x 500 feet)
Percentages must add to 100%.
Impervious surface percentage must be a positive number.
Pervious surface percentage must be a positive number.
Vegetated surface percentage must be a positive number.
Record the extent of each type of garbage on the adjacent shoreline.


Who would have guessed you could find such an amazing rush of emotions in a capsule? The intensity of simply scratching my scalp while in the hands of Adderall is outstanding and I could not possibly feel better about any of this. And isn't it ironic.
For a year now I've been chomping down Adderall which, I might add, has never once been prescribed to me. I'm currently in high school and when it comes to grades, I've always had complete lack of ambition. One of my friends suggested that I may have ADD and I should probably see a doctor about it before my grades decline anymore. Of course, me being as shy as I was, I couldn't even bring myself to tell my own parents I was having trouble paying attention in school and that I felt very apathetic in school. Hence, plan B: Make new friends.
I met this girl in gym class who had recently gotten a prescription of Adderall and we became good friends. Eventually, she noted my lack of motivation and offered up some of her adderall. Actually, initially, I offered some Adderall to her, which I had previously stolen from another friend, and she got her doctor to prescribe her some. I quickly became an addict and I've denied it all year promising myself it was more than possible to stop at any given time, I just didn't want to. Anyway, this girl who we'll call Anna, gave me more and more because I kept insisting she help me out as a friend. I then suggested that Anna go back to her doctor and tell them it's not working well enough and it wears out about half-way through the day. Thus, her prescription kept rising.
Anna pulled this stunt for me every time I told her to, eventually reaching 30mg capsules for a 105 lb. girl. This was obviously an ample amount for both of us to handle, and I kept insisting on more and more. At the beginning of each week, I would receive 5-10 30mg. capsules of Adderall.
About 2/3 through the year, I noticed how drastically my social skills have changed. I've always had a lot of friends, and I've always been the outgoing one in school; however, for nearly all of my second semester, I realized how bitter and resentful I was around people when I hadn't consumed enough Adderall or if it was even beginning to wear off. I still have quite a few friends, but they've certainly noted my general hatred for everyone and my somewhat anti-social thoughts/behaviour; some of my friends have even confronted me about it more than once.
For example, one boy we'll call Joe had a bit of a liking for me, so he invited me to his house. By the end of the school day, the euphoric effects of Adderall wear off quickly and my mood shifts from extremely happy to bitter and spiteful. Joe, not ever realizing this before, was genuinely excited to have me over and tried to engage in thoughtful conversation about whatever. I was definitely crashing. I ended up hardly saying a word and constantly making situations very, very awkward. After Joe saw me like this several more times, he began to complain. When I tried to explain, it pretty much ruined that relationship and we haven't hung out since.
Adderall has brought me to many places. Gradewise, I was much improved. Adderall allowed me to open up in front of class, raising my hand much more often, questioning things, et cetera, and take much more efficient notes. Also: I've never really studied for a test that hard in my whole life. Even with adderall, I still didn't study for tests, but before big quizes/tests/exams, I always took a fair amount of Adderall and my reasoning for things seemed so much clearer, and I felt this gave me a great advantage. My test grades have improved greatly. Projects become more in depth and thought out. Although they may become a little excessive, my overall project had a persuasive vibe about it.
Despite how much Adderall may have helped me this year in school, I would do anything to go back before I had ever heard of adderall, before anyone suggested ADD, before anyone offered me anything, before I became so careless and drug friendly.
Walking around the school at lunch, I've noticed I think paranoid thoughts often. Adderall has also seemed to create some symptoms of OCD: skipping cracks, insane amounts of cleaning, organizing of all school work, checking the same grade more than three times a day, not touching doorhandles, not using public restrooms, chewing on my cheeks eventually swallowing large amounts of blood, scratching at my face unable to stop for more than a second or two, biting my nails until they bleed and then a little more, writing very long journal entries multiple times in a day at certain hours, and quite a few other tics.
Overall, I would say Adderall has made my life an intense version of hell with short releases of euphoria. I promised myself all year I would stop this summer and now here I am, still going strong, stronger than ever. I regret all of this. I've created awkward gaps in the relationships with my friends. I hardly recognize myself anymore. This cannot be happiness. This can not be improvement. This is me crashing. I regret my actions every day. When intense hunger hits and I am reminded of what a waste this year has been because of a simple pill and my poor decision.
I'm home from school, I started this entry quite a while ago, and I feel as though I should curl up and die. These are my pupils getting smaller, this is hunger hitting and cheeks bleeding and my life completely going to a warped, apathetic-like depression. 'Trip' always reminded me of 'vacation'. Adderall is no trip, we're here forever.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Enzymes of Glycolysis
This table contains entries for the ten enzymes in glycolysis for a few representative organisms from the UniProt database, with links to view the original protein entries.
|
|
UniProt entry
|
Protein name |
Organism |
|
Hexokinase |
Hexokinase, type I |
Homo sapiens |
|
|
Hexokinase, type II |
Homo sapiens |
||
|
|
Hexokinase type III |
Homo sapiens |
|
|
|
Glucokinase
(Hexokinase type IV) |
Homo sapiens |
|
|
Phosphoglucose isomerase |
Glucose-6-phosphate isomerase |
Homo sapiens |
|
|
Glucose-6-phosphate isomerase |
Escherichia coli |
||
|
Phosphofructokinase |
6-phosphofructokinase, muscle type |
Homo sapiens |
|
|
6-phosphofructokinase, liver type |
Homo sapiens |
||
|
|
6-phosphofructokinase, type C |
Homo sapiens |
|
|
|
6-phosphofructokinase isozyme I |
Escherichia coli |
|
|
Fructose-bisphosphate
aldolase |
Fructose-bisphosphate
aldolase A |
Homo sapiens |
|
|
Fructose-bisphosphate
aldolase B |
Homo
sapiens |
||
|
|
Fructose-bisphosphate
aldolase C |
Homo sapiens |
|
|
|
Fructose-bisphosphate aldolase class I |
Escherichia coli |
|
|
|
Fructose-bisphosphate
aldolase class II |
Escherichia coli |
|
|
Triosephosphate isomerase |
Triosephosphate isomerase |
Homo sapiens |
|
|
Triosephosphate isomerase |
Escherichia coli |
||
|
Glyceraldehyde 3-phosphate dehydrogenase |
Glyceraldehyde 3-phosphate dehydrogenase, muscle |
Homo sapiens |
|
|
Glyceraldehyde 3-phosphate dehydrogenase, liver |
Homo sapiens |
||
|
|
Glyceraldehyde
3-phosphate dehydrogenase, testis-specific |
Homo sapiens |
|
|
|
Glyceraldehyde
3-phosphate dehydrogenase A |
Escherichia coli |
|
|
|
Glyceraldehyde
3-phosphate dehydrogenase C |
Escherichia coli |
|
|
Phosphoglycerate kinase |
Phosphoglycerate kinase 1 |
Homo sapiens |
|
|
Phosphoglycerate kinase, testis specific |
Homo sapiens |
||
|
|
Phosphoglycerate
kinase |
Escherichia coli |
|
|
Phosphoglycerate mutase |
Phosphoglycerate
mutase 1 |
Homo
sapiens |
|
|
Phosphoglycerate mutase 2 |
Homo sapiens |
||
|
|
Putative phosphoglycerate mutase 3 |
Homo sapiens |
|
|
|
2,3-bisphosphoglycerate-dependent
phosphoglycerate mutase |
Escherichia coli |
|
|
|
Probable
phosphoglycerate mutase gpmB |
Escherichia coli |
|
|
Enolase |
Alpha enolase |
Homo sapiens |
|
|
Beta enolase |
Homo sapiens |
||
|
|
Gamma enolase |
Homo sapiens |
|
|
|
Alpha enolase,
lung specific |
Homo sapiens |
|
|
|
Enolase |
Escherichia coli |
|
|
Pyruvate kinase |
Pyruvate
kinase, M1 isozyme |
Homo sapiens |
|
|
Pyruvate
kinase, M2 isozyme |
Homo sapiens |
||
|
|
Pyruvate kinase,
isozymes R/L |
Homo sapiens |
|
|
|
Pyruvate kinase
I |
Escherichia coli |
|
|
|
Pyruvate kinase
II |
Escherichia coli |


let us grow together
First off WordPress is Search Engine Optimization enhanced. There are a couple of modifications that you will need to
make yet generally there are several SEO benefits that WordPress provides to your free of cost. This saves you a
significant amount of time and effort that is generally required when you are producing your website to be SEO enhanced.
Another excellent advantage of WordPress for local business owners is that the material is quickly upgraded and also you will not even have to know any type of HTML to get it done either. You can conveniently develop new web pages or modify your existing pages making use of a straightforward rich full-screen editor. This is one more fantastic way for you to conserve money when you are first creating your site.
Apply NowThere are likewise countless individuals in the net globe that develop expansions of the WordPress program. Simply believe the number of complementary styles as well as scores, amongst thousands of various other options, are offered to you for free. You will not have to pay the substantial rate you would typically have to for an internet designer because these extensions will certainly enable you to do it for yourself.
Apply NowA few of our new hires.
Come join the team
"The training had me up to speed quickly. I'm making more money than my full-time job. I work only 5 hours a week."
"Go up to speed really fast. The classes were easy to understand. But what got me the most was the pay."
"I just was able to cover my rent in one week of working. Need I say more."


Assigning a tool to the right mouse button
For those of you with multi-button mice, you might find it extremely useful to specify a tool and color to be executed by your right mouse button in complement to your left. Pixen makes this easy.
To assign a tool to your right mouse button:
Look at the tool palette and find the right tool disclosure area ().
If the arrow is pointing to the right, click it, and the right tool configurator will open.
The right tool area behaves just like the left tool area: just click a tool to select it.
If you don't have a two-button mouse, you can still leverage this feature: holding the control key emulates the right mouse button.


|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| Closeable | A Closeable is a source or destination of data that can be closed. |
| DataInput | The DataInput interface provides
for reading bytes from a binary stream and
reconstructing from them data in any of
the Java primitive types. |
| DataOutput | The DataOutput interface provides
for converting data from any of the Java
primitive types to a series of bytes and
writing these bytes to a binary stream. |
| Externalizable | Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the responsibility of the class to save and restore the contents of its instances. |
| FileFilter | A filter for abstract pathnames. |
| FilenameFilter | Instances of classes that implement this interface are used to filter filenames. |
| Flushable | A Flushable is a destination of data that can be flushed. |
| ObjectInput | ObjectInput extends the DataInput interface to include the reading of objects. |
| ObjectInputValidation | Callback interface to allow validation of objects within a graph. |
| ObjectOutput | ObjectOutput extends the DataOutput interface to include writing of objects. |
| ObjectStreamConstants | Constants written into the Object Serialization Stream. |
| Serializable | Serializability of a class is enabled by the class implementing the java.io.Serializable interface. |
| Class Summary | |
|---|---|
| BufferedInputStream | A BufferedInputStream adds
functionality to another input stream-namely,
the ability to buffer the input and to
support the mark and reset
methods. |
| BufferedOutputStream | The class implements a buffered output stream. |
| BufferedReader | Read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines. |
| BufferedWriter | Write text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings. |
| ByteArrayInputStream | A ByteArrayInputStream contains
an internal buffer that contains bytes that
may be read from the stream. |
| ByteArrayOutputStream | This class implements an output stream in which the data is written into a byte array. |
| CharArrayReader | This class implements a character buffer that can be used as a character-input stream. |
| CharArrayWriter | This class implements a character buffer that can be used as an Writer. |
| DataInputStream | A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way. |
| DataOutputStream | A data output stream lets an application write primitive Java data types to an output stream in a portable way. |
| File | An abstract representation of file and directory pathnames. |
| FileDescriptor | Instances of the file descriptor class serve as an opaque handle to the underlying machine-specific structure representing an open file, an open socket, or another source or sink of bytes. |
| FileInputStream | A FileInputStream obtains input bytes
from a file in a file system. |
| FileOutputStream | A file output stream is an output stream for writing data to a
File or to a FileDescriptor . |
| FilePermission | This class represents access to a file or directory. |
| FileReader | Convenience class for reading character files. |
| FileWriter | Convenience class for writing character files. |
| FilterInputStream | A FilterInputStream contains
some other input stream, which it uses as
its basic source of data, possibly transforming
the data along the way or providing additional
functionality. |
| FilterOutputStream | This class is the superclass of all classes that filter output streams. |
| FilterReader | Abstract class for reading filtered character streams. |
| FilterWriter | Abstract class for writing filtered character streams. |
| InputStream | This abstract class is the superclass of all classes representing an input stream of bytes. |
| InputStreamReader | An InputStreamReader is a bridge from byte streams to character streams: It
reads bytes and decodes them into characters using a specified . |
| LineNumberInputStream | Deprecated. This class incorrectly assumes that bytes adequately represent characters. |
| LineNumberReader | A buffered character-input stream that keeps track of line numbers. |
| ObjectInputStream | An ObjectInputStream deserializes primitive data and objects previously written using an ObjectOutputStream. |
| ObjectInputStream.GetField | Provide access to the persistent fields read from the input stream. |
| ObjectOutputStream | An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream. |
| ObjectOutputStream.PutField | Provide programmatic access to the persistent fields to be written to ObjectOutput. |
| ObjectStreamClass | Serialization's descriptor for classes. |
| ObjectStreamField | A description of a Serializable field from a Serializable class. |
| OutputStream | This abstract class is the superclass of all classes representing an output stream of bytes. |
| OutputStreamWriter | An OutputStreamWriter is a bridge from character streams to byte streams:
Characters written to it are encoded into bytes using a specified . |
| PipedInputStream | A piped input stream should be connected to a piped output stream; the piped input stream then provides whatever data bytes are written to the piped output stream. |
| PipedOutputStream | A piped output stream can be connected to a piped input stream to create a communications pipe. |
| PipedReader | Piped character-input streams. |
| PipedWriter | Piped character-output streams. |
| PrintStream | A PrintStream adds functionality to another output stream,
namely the ability to print representations of various data values
conveniently. |
| PrintWriter | Print formatted representations of objects to a text-output stream. |
| PushbackInputStream | A PushbackInputStream adds
functionality to another input stream, namely
the ability to "push back" or "unread"
one byte. |
| PushbackReader | A character-stream reader that allows characters to be pushed back into the stream. |
| RandomAccessFile | Instances of this class support both reading and writing to a random access file. |
| Reader | Abstract class for reading character streams. |
| SequenceInputStream | A SequenceInputStream represents
the logical concatenation of other input
streams. |
| SerializablePermission | This class is for Serializable permissions. |
| StreamTokenizer | The StreamTokenizer class takes an input stream and
parses it into "tokens", allowing the tokens to be
read one at a time. |
| StringBufferInputStream | Deprecated. This class does not properly convert characters into bytes. |
| StringReader | A character stream whose source is a string. |
| StringWriter | A character stream that collects its output in a string buffer, which can then be used to construct a string. |
| Writer | Abstract class for writing to character streams. |
| Exception Summary | |
|---|---|
| CharConversionException | Base class for character conversion exceptions. |
| EOFException | Signals that an end of file or end of stream has been reached unexpectedly during input. |
| FileNotFoundException | Signals that an attempt to open the file denoted by a specified pathname has failed. |
| InterruptedIOException | Signals that an I/O operation has been interrupted. |
| InvalidClassException | Thrown when the Serialization runtime detects one of the following problems with a Class. |
| InvalidObjectException | Indicates that one or more deserialized objects failed validation tests. |
| IOException | Signals that an I/O exception of some sort has occurred. |
| NotActiveException | Thrown when serialization or deserialization is not active. |
| NotSerializableException | Thrown when an instance is required to have a Serializable interface. |
| ObjectStreamException | Superclass of all exceptions specific to Object Stream classes. |
| OptionalDataException | Exception indicating the failure of an object read operation due to unread primitive data, or the end of data belonging to a serialized object in the stream. |
| StreamCorruptedException | Thrown when control information that was read from an object stream violates internal consistency checks. |
| SyncFailedException | Signals that a sync operation has failed. |
| UnsupportedEncodingException | The Character Encoding is not supported. |
| UTFDataFormatException | Signals that a malformed string in modified UTF-8 format has been read in a data input stream or by any class that implements the data input interface. |
| WriteAbortedException | Signals that one of the ObjectStreamExceptions was thrown during a write operation. |
Provides for system input and output through data streams, serialization and the file system. Unless otherwise noted, passing a null argument to a constructor or method in any class or interface in this package will cause a NullPointerException to be thrown.
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
Copyright © 2004, 2010 Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.


This page was created by Juš Mirtič in collaboration with Miha Zupan in 2018 for the purposes of it lessons at Gimnazija Bežigrad.
Vam je stran všeč?
Oglej si še druge dele spletišča!