For some time I've been looking into diverting the surplus (that I sell to the grid) from my PV to a battery backup system. Now I know that there are commercial systems out there but they are expensive and generally use Lead acid batteries which have a limited DOD and number of cycles. Also you cannot have a battery system and an immersion heater dump at the same time as both would require their own CT on the incoming main and there is no way to get the two systems to talk to each other to set priorities. The commercial Hybrid Inverters are all about maximumising self consumption and some have UPS functionality but I haven't seen one yet that allows you to reserve some of the battery capacity purely against mains failure.
Robin Emley' Mk2 router being 'open source' is extensible so multiple outputs are possible. A little extra code and some other inputs in its ATMEGA heart would sort the priority problem, but you then need a charging circuit that can handle a 'reduced' input supply (say when there is only 600watts spare from the PV and the nominal input to the charger is 1KW). Robins output circuit is a simple TRIAC and I presume that his quest for CE marking will take the optical isolation route and MOFET's. That being so, it should be possible to change the output switching to high speed PWM. This would also avoid the need for an 'anti flicker' mode.
In terms of batteries LiFePO4 seams to be the way to go especially as it can be kept at a partial charge. Now most efficient voltage reducers/charging circuits use the so called PWM Buck/Boost circuits, so as to not waste energy as heat. I am wondering therefore if it is possible to build a charger that uses PWM but where the width of the pulses is controlled by both the need to divert current away from being sold to the grid and the charging requirements of the battery. Anything that is left over can go to an immersion heater.
From the self consumption point of view if you have inputs to the CPU that are monitoring the battery and you are already monitoring the direction and quantity of flow of power in your supply, it should be possible to provide control signals to the battery powered inverter to produce just enough output to prevent import when the battery is charged until you get to a predetermined, priority set, mid point DOD. As well as telling the inverter that mains has failed so it has to handle the whole load until the maximum DOD is reached.
Has anybody any thoughts on this approach or suggestion for existing kit that could be building blocks in such a system?
Re: Using Surplus PV output for battery charging
I think most systems have the batteries on the DC side, so they would charge until full and then the PV would be converted as normal to AC and if you have a diverter, then any excess over house consumption would be diverted. Which would seem to be the best way to do things. A full charge would last all night if the batteries are large enough.
I'm not sure what the advantages would be of what I understand you are proposing which is to have a partially charged set of batteries and some PV diverted.
I'm sure you've googled the commercial offerings on the market which vary from a sort of UPS functionality to full systems. Have you also seen the Tesla system which apparently should be available next year?
Re: Using Surplus PV output for battery charging
We have had a Solaredge PV system installed since mid-2012. Have just received their StorEdge sales on Optimising Self-Consumption with a 7kW Tesla Powerwall battery Pack and control through their StorEdge Interface, which can't be cheap...!... There is an interesting article from the Guardian which shows the economic issues of this...
However, their interface may be of interest for more info on how it deals with the time-shifting of the PV-derived energy to non-PV periods.
How it works during shorter-day-lengths/poor weather comes back to the point of concern above, ie how to deal with partially charged batteries...I do not think there is a complete answer, unless we can be plugged into your friendly wind-farm, hydro scheme...Maybe shifting supplier of "Clean" energy is part of the equation, as suggested elsewhere.
We have a Thermodynamic MagicBox (Air-Gas-Hot Water), and a big tank(!), installed over a year ago, which uses 600W of electricity, for a couple of hours, to heat. We use a timer, at present, to put the operation into PV generation period, to improve efficiency (but variable, of course). We also have a SolarImmersion (PWM) diverter, which has a separate switched outlet for further diversion once the Immersion Heater Thermometer cuts in.
The Immersun (spelling?) diverter looks more advanced with possibility of linking two via wifi, giving possibility of one for an immersion heater and a second to feed a UPS, say...
We've just got the emonpi to carry out accurate monitoring...Must get the Gas pulse-monitoring sorted, next...
I am thinking of possibilities to split the load, to deal with time-shifting.
1. We have changed all our light bulbs for Low-Energy ones, so use of a (fairly small) UPS and switch control is practical and relatively cheap...
2. Build a second smaller (1-2kW) PV system, with 200Ah Batteries ( but without FIT benefit!) to deal with lights and overnight (Fridge/Freezer/etc.) load and help with the day-time running, by time-shifting...Amore costly solution
3. Upgrade the Solaredge with StorEdge...Requires Lottery Win...Hell freezing over looks like being delayed by Global Warming, tho!...


001/* 002// This software is subject to the terms of the Eclipse Public License v1.0 003// Agreement, available at the following URL: 004// http://www.eclipse.org/legal/epl-v10.html. 005// You must accept the terms of that agreement to use this software. 006// 007// Copyright (C) 2008-2013 Pentaho 008// All Rights Reserved. 009*/ 010package mondrian.spi; 011 012import mondrian.rolap.SqlStatement; 013 014import java.sql.ResultSetMetaData; 015import java.sql.SQLException; 016import java.util.List; 017import java.util.Map; 018 019/** 020 * Description of an SQL dialect. 021 * 022 *
Instantiating a dialect
 023 * 024 *
A dialect is instantiated via a {@link DialectFactory}.
 025 * 026 *
In JDBC terms, a dialect is analogous to a {@link java.sql.Connection}, 027 * and a dialect factory is analogous to a {@link java.sql.Driver}, in the 028 * sense that the JDBC driver manager maintains a chain of registered drivers, 029 * and each driver in turn is given the opportunity to create a connection 030 * that can handle a particular JDBC connect string. For dialects, each 031 * registered dialect factory is given the chance to create a dialect that 032 * matches a particular connection.
 033 * 034 *
A dialect factory may be explicit or implicit:
 035 * 036 *
An explicit factory is declared by creating a public 037 * static final member in the dialect class called 038 * "FACTORY".
 039 * 040 *
If there is no explicit factory, Mondrian requires that the class has 041 * a public constructor that takes a {@link java.sql.Connection} as its 042 * sole parameter, and the {@link DialectManager} creates an implicit 043 * factory that calls that constructor.
 044 * 045 *

 046 * 047 *
Dialect factories can also be the means for caching or pooling dialects. 048 * See {@link #allowsDialectSharing} and 049 * {@link mondrian.spi.DialectFactory} for more details.
 050 * 051 *
Registering dialects
 052 * 053 *
A dialect needs to be registered with the system in order to be used. 054 * Call {@link mondrian.spi.DialectManager#register(DialectFactory)} 055 * to register a dialect factory, or 056 * {@link mondrian.spi.DialectManager#register(Class)} to register a dialect 057 * class. 058 * 059 *
Mondrian can load dialects on startup. To enable this for your dialect, 060 *
 061 *
Place your dialect class in a JAR file. 062 *
Include in the JAR file a file called 063 * "META-INF/services/mondrian.spi.Dialect", containing the 064 * name of your dialect class.
 065 *
Ensure that the JAR file is on the class path. 066 *
 067 * 068 *
Writing a dialect
 069 * 070 *
To implement a dialect, write a class that implements the {@code Dialect} 071 * interface. It is recommended that you subclass 072 * {@link mondrian.spi.impl.JdbcDialectImpl}, to help to make your 073 * dialect is forwards compatible, but it is not mandatory.
 074 * 075 *
A dialects should be immutable. Mondrian assumes that dialects can safely 076 * be shared between threads that use the same 077 * {@link java.sql.Connection JDBC connection} without synchronization. If 078 * {@link #allowsDialectSharing()} returns true, Mondrian 079 * may use the same dialect for different connections from the same 080 * {@link javax.sql.DataSource JDBC data source}.
 081 * 082 *
Load the FoodMart data set into your database, and run Mondrian's suite of 083 * regression tests. In particular, get {@code mondrian.test.DialectTest} to run 084 * cleanly first; this will ensure that the dialect's claims are consistent with 085 * the actual behavior of your database.
 086 * 087 * @see mondrian.spi.DialectFactory 088 * @see mondrian.spi.DialectManager 089 * 090 * @author jhyde 091 * @since Oct 10, 2008 092 */ 093public interface Dialect { 094 /** 095 * Converts an expression to upper case. 096 * 097 *
For example, for MySQL, {@code toUpper("foo.bar")} returns 098 * {@code "UPPER(foo.bar)"}.
 099 * 100 * @param expr SQL expression 101 * 102 * @return SQL syntax that converts expr 103 * into upper case. 104 */ 105 String toUpper(String expr); 106 107 /** 108 * Generates a conditional statement in this dialect's syntax. 109 * 110 *
For example, {@code caseWhenElse("b", "1", "0")} returns 111 * {@code "case when b then 1 else 0 end"} on Oracle, 112 * {@code "Iif(b, 1, 0)"} on Access. 113 * 114 * @param cond Predicate expression 115 * @param thenExpr Expression if condition is true 116 * @param elseExpr Expression if condition is false 117 * @return Conditional expression 118 */ 119 String caseWhenElse( 120 String cond, 121 String thenExpr, 122 String elseExpr); 123 124 /** 125 * Encloses an identifier in quotation marks appropriate for this 126 * Dialect. 127 * 128 *
For example, 129 * quoteIdentifier("emp") yields a string containing 130 * "emp" in Oracle, and a string containing 131 * [emp] in Access. 132 * 133 * @param val Identifier 134 * 135 * @return Quoted identifier 136 */ 137 String quoteIdentifier(String val); 138 139 /** 140 * Appends to a buffer an identifier, quoted appropriately for this 141 * Dialect. 142 * 143 * @param val identifier to quote (must not be null). 144 * @param buf Buffer 145 */ 146 void quoteIdentifier(String val, StringBuilder buf); 147 148 /** 149 * Encloses an identifier in quotation marks appropriate for the 150 * current SQL dialect. For example, in Oracle, where the identifiers 151 * are quoted using double-quotes, 152 * quoteIdentifier("schema","table") yields a string 153 * containing "schema"."table". 154 * 155 * @param qual Qualifier. If it is not null, 156 * "qual". is prepended. 157 * @param name Name to be quoted. 158 * @return Quoted identifier 159 */ 160 String quoteIdentifier( 161 String qual, 162 String name); 163 164 /** 165 * Appends to a buffer a list of identifiers, quoted 166 * appropriately for this Dialect. 167 * 168 *
Names in the list may be null, but there must be at least one 169 * non-null name in the list.
 170 * 171 * @param buf Buffer 172 * @param names List of names to be quoted 173 */ 174 void quoteIdentifier( 175 StringBuilder buf, 176 String... names); 177 178 /** 179 * Returns the character which is used to quote identifiers, or null 180 * if quoting is not supported. 181 * 182 * @return identifier quote 183 */ 184 String getQuoteIdentifierString(); 185 186 /** 187 * Appends to a buffer a single-quoted SQL string. 188 * 189 *
For example, in the default dialect, 190 * quoteStringLiteral(buf, "Can't") appends 191 * "'Can''t'" to buf. 192 * 193 * @param buf Buffer to append to 194 * @param s Literal 195 */ 196 void quoteStringLiteral( 197 StringBuilder buf, 198 String s); 199 200 /** 201 * Appends to a buffer a numeric literal. 202 * 203 *
In the default dialect, numeric literals are printed as is. 204 * 205 * @param buf Buffer to append to 206 * @param value Literal 207 */ 208 void quoteNumericLiteral( 209 StringBuilder buf, 210 String value); 211 212 /** 213 * Appends to a buffer a boolean literal. 214 * 215 *
In the default dialect, boolean literals are printed as is. 216 * 217 * @param buf Buffer to append to 218 * @param value Literal 219 */ 220 void quoteBooleanLiteral( 221 StringBuilder buf, 222 String value); 223 224 /** 225 * Appends to a buffer a date literal. 226 * 227 *
For example, in the default dialect, 228 * quoteStringLiteral(buf, "1969-03-17") 229 * appends DATE '1969-03-17'. 230 * 231 * @param buf Buffer to append to 232 * @param value Literal 233 */ 234 void quoteDateLiteral( 235 StringBuilder buf, 236 String value); 237 238 /** 239 * Appends to a buffer a time literal. 240 * 241 *
For example, in the default dialect, 242 * quoteStringLiteral(buf, "12:34:56") 243 * appends TIME '12:34:56'. 244 * 245 * @param buf Buffer to append to 246 * @param value Literal 247 */ 248 void quoteTimeLiteral( 249 StringBuilder buf, 250 String value); 251 252 /** 253 * Appends to a buffer a timestamp literal. 254 * 255 *
For example, in the default dialect, 256 * quoteStringLiteral(buf, "1969-03-17 12:34:56") 257 * appends TIMESTAMP '1969-03-17 12:34:56'. 258 * 259 * @param buf Buffer to append to 260 * @param value Literal 261 */ 262 void quoteTimestampLiteral( 263 StringBuilder buf, 264 String value); 265 266 /** 267 * Returns whether this Dialect requires subqueries in the FROM clause 268 * to have an alias. 269 * 270 * @see #allowsFromQuery() 271 * 272 * @return whether dialewct requires subqueries to have an alias 273 */ 274 boolean requiresAliasForFromQuery(); 275 276 /** 277 * Returns whether the SQL dialect allows "AS" in the FROM clause. 278 * If so, "SELECT * FROM t AS alias" is a valid query. 279 * 280 * @return whether dialect allows AS in FROM clause 281 */ 282 boolean allowsAs(); 283 284 /** 285 * Returns whether this Dialect allows a subquery in the from clause, 286 * for example 287 * 288 *
SELECT * FROM (SELECT * FROM t) AS 289 * x
 290 * 291 * @see #requiresAliasForFromQuery() 292 * 293 * @return whether Dialect allows subquery in FROM clause 294 */ 295 boolean allowsFromQuery(); 296 297 /** 298 * Returns whether this Dialect allows multiple arguments to the 299 * COUNT(DISTINCT ...) aggregate function, for example 300 * 301 *
SELECT COUNT(DISTINCT x, y) FROM t
 302 * 303 * @see #allowsCountDistinct() 304 * @see #allowsMultipleCountDistinct() 305 * 306 * @return whether Dialect allows multiple arguments to COUNT DISTINCT 307 */ 308 boolean allowsCompoundCountDistinct(); 309 310 /** 311 * Returns whether this Dialect supports distinct aggregations. 312 * 313 *
For example, Access does not allow 314 *
 315 * select count(distinct x) from t 316 *
 317 * 318 * @return whether Dialect allows COUNT DISTINCT 319 */ 320 boolean allowsCountDistinct(); 321 322 /** 323 * Returns whether this Dialect supports more than one distinct 324 * aggregation in the same query. 325 * 326 *
In Derby 10.1, 327 *
 328 * select couunt(distinct x) from t 329 *
 330 * is OK, but 331 *
 332 * select couunt(distinct x), count(distinct y) from t 333 *
 334 * gives "Multiple DISTINCT aggregates are not supported at this time." 335 * 336 * @return whether this Dialect supports more than one distinct 337 * aggregation in the same query 338 */ 339 boolean allowsMultipleCountDistinct(); 340 341 /** 342 * Returns whether this Dialect has performant support of distinct SQL 343 * measures in the same query. 344 * 345 * @return whether this dialect supports multiple count(distinct subquery) 346 * measures in one query. 347 */ 348 boolean allowsMultipleDistinctSqlMeasures(); 349 350 /** 351 * Generates a SQL statement to represent an inline dataset. 352 * 353 *
For example, for Oracle, generates 354 * 355 *
 356 * SELECT 1 AS FOO, 'a' AS BAR FROM dual 357 * UNION ALL 358 * SELECT 2 AS FOO, 'b' AS BAR FROM dual 359 *
 360 * 361 *
For ANSI SQL, generates: 362 * 363 *
 364 * VALUES (1, 'a'), (2, 'b') 365 *
 366 * 367 * @param columnNames List of column names 368 * @param columnTypes List of column types ("String" or "Numeric") 369 * @param valueList List of rows values 370 * @return SQL string 371 */ 372 String generateInline( 373 List<String> columnNames, 374 List<String> columnTypes, 375 List<String[]> valueList); 376 377 /** 378 * If Double values need to include additional exponent in its string 379 * represenation. This is to make sure that Double literals will be 380 * interpreted as doubles by LucidDB. 381 * 382 * @param value Double value to generate string for 383 * @param valueString java string representation for this value. 384 * @return whether an additional exponent "E0" needs to be appended 385 * 386 */ 387 boolean needsExponent(Object value, String valueString); 388 389 /** 390 * Appends to a buffer a value quoted for its type. 391 * 392 * @param buf Buffer to append to 393 * @param value Value 394 * @param datatype Datatype of value 395 */ 396 void quote( 397 StringBuilder buf, 398 Object value, 399 Datatype datatype); 400 401 /** 402 * Returns whether this dialect supports common SQL Data Definition 403 * Language (DDL) statements such as CREATE TABLE and 404 * DROP INDEX. 405 * 406 *
Access seems to allow DDL iff the .mdb file is writeable. 407 * 408 * @see java.sql.DatabaseMetaData#isReadOnly() 409 * 410 * @return whether this Dialect supports DDL 411 */ 412 boolean allowsDdl(); 413 414 /** 415 * Generates an item for an ORDER BY clause, sorting in the required 416 * direction, and ensuring that NULL values collate either before or after 417 * all non-NULL values, depending on the collateNullsLast 418 * parameter. 419 * 420 * @param expr Expression 421 * @param nullable Whether expression may have NULL values 422 * @param ascending Whether to sort expression ascending 423 * @param collateNullsLast Whether the null values should be sorted first 424 * or last. 425 * 426 * @return Expression modified so that NULL values collate last 427 */ 428 String generateOrderItem( 429 String expr, 430 boolean nullable, 431 boolean ascending, 432 boolean collateNullsLast); 433 434 /** 435 * Returns whether this Dialect supports expressions in the GROUP BY 436 * clause. Derby/Cloudscape and Infobright do not. 437 * 438 * @return Whether this Dialect allows expressions in the GROUP BY 439 * clause 440 */ 441 boolean supportsGroupByExpressions(); 442 443 /** 444 * Returns whether this Dialect allows the GROUPING SETS construct in 445 * the GROUP BY clause. Currently Greenplum, IBM DB2, Oracle, and Teradata. 446 * 447 * @return Whether this Dialect allows GROUPING SETS clause 448 */ 449 boolean supportsGroupingSets(); 450 451 /** 452 * Returns whether this Dialect places no limit on the number 453 * of rows which can appear as elements of an IN or VALUES 454 * expression. 455 * 456 * @return whether value list length is unlimited 457 */ 458 boolean supportsUnlimitedValueList(); 459 460 /** 461 * Returns true if this Dialect can include expressions in the GROUP BY 462 * clause only by adding an expression to the SELECT clause and using 463 * its alias. 464 * 465 *
For example, in such a dialect, 466 *
 467 * SELECT x, x FROM t GROUP BY x 468 *
 469 * would be illegal, but 470 *
 471 * SELECT x AS a, x AS b FROM t ORDER BY a, b 472 *
 473 * 474 * would be legal.
 475 * 476 *
Infobright is the only such dialect.
 477 * 478 * @return Whether this Dialect can include expressions in the GROUP BY 479 * clause only by adding an expression to the SELECT clause and using 480 * its alias 481 */ 482 boolean requiresGroupByAlias(); 483 484 /** 485 * Returns true if this Dialect can include expressions in the ORDER BY 486 * clause only by adding an expression to the SELECT clause and using 487 * its alias. 488 * 489 *
For example, in such a dialect, 490 *
 491 * SELECT x FROM t ORDER BY x + y 492 *
 493 * would be illegal, but 494 *
 495 * SELECT x, x + y AS z FROM t ORDER BY z 496 *
 497 * 498 * would be legal.
 499 * 500 *
MySQL, DB2 and Ingres are examples of such dialects.
 501 * 502 * @return Whether this Dialect can include expressions in the ORDER BY 503 * clause only by adding an expression to the SELECT clause and using 504 * its alias 505 */ 506 boolean requiresOrderByAlias(); 507 508 /** 509 * Returns true if this Dialect can include expressions in the HAVING 510 * clause only by adding an expression to the SELECT clause and using 511 * its alias. 512 * 513 *
For example, in such a dialect, 514 *
 515 * SELECT CONCAT(x) as foo FROM t HAVING CONCAT(x) LIKE "%" 516 *
 517 * would be illegal, but 518 *
 519 * SELECT CONCAT(x) as foo FROM t HAVING foo LIKE "%" 520 *
 521 * 522 * would be legal.
 523 * 524 *
MySQL is an example of such dialects.
 525 * 526 * @return Whether this Dialect can include expressions in the HAVING 527 * clause only by adding an expression to the SELECT clause and using 528 * its alias 529 */ 530 boolean requiresHavingAlias(); 531 532 /** 533 * Returns true if aliases defined in the SELECT clause can be used as 534 * expressions in the ORDER BY clause. 535 * 536 *
For example, in such a dialect, 537 *
 538 * SELECT x, x + y AS z FROM t ORDER BY z 539 *
 540 * 541 * would be legal.
 542 * 543 *
MySQL, DB2 and Ingres are examples of dialects where this is true; 544 * Access is a dialect where this is false.
 545 * 546 * @return Whether aliases defined in the SELECT clause can be used as 547 * expressions in the ORDER BY clause. 548 */ 549 boolean allowsOrderByAlias(); 550 551 /** 552 * Returns true if this dialect allows only integers in the ORDER BY 553 * clause of a UNION (or other set operation) query. 554 * 555 *
For example, 556 * 557 * SELECT x, y + z FROM t
 558 * UNION ALL
 559 * SELECT x, y + z FROM t
 560 * ORDER BY 1, 2 561 * 562 * is allowed but 563 * 564 * SELECT x, y, z FROM t
 565 * UNION ALL
 566 * SELECT x, y, z FROM t
 567 * ORDER BY x 568 * 569 * is not. 570 * 571 *
Teradata is an example of a dialect with this restriction. 572 * 573 * @return whether this dialect allows only integers in the ORDER BY 574 * clause of a UNION (or other set operation) query 575 */ 576 boolean requiresUnionOrderByOrdinal(); 577 578 /** 579 * Returns true if this dialect allows an expression in the ORDER BY 580 * clause of a UNION (or other set operation) query only if it occurs in 581 * the SELECT clause. 582 * 583 *
For example, 584 * 585 * SELECT x, y + z FROM t
 586 * UNION ALL
 587 * SELECT x, y + z FROM t
 588 * ORDER BY y + z 589 * 590 * is allowed but 591 * 592 * SELECT x, y, z FROM t
 593 * UNION ALL
 594 * SELECT x, y, z FROM t
 595 * ORDER BY y + z 596 * SELECT x, y, z FROM t ORDER BY y + z 597 * 598 * is not. 599 * 600 *
Access is an example of a dialect with this restriction. 601 * 602 * @return whether this dialect allows an expression in the ORDER BY 603 * clause of a UNION (or other set operation) query only if it occurs in 604 * the SELECT clause 605 */ 606 boolean requiresUnionOrderByExprToBeInSelectClause(); 607 608 /** 609 * Returns true if this dialect supports multi-value IN expressions. 610 * E.g., 611 * 612 * WHERE (col1, col2) IN ((val1a, val2a), (val1b, val2b)) 613 * 614 * @return true if the dialect supports multi-value IN expressions 615 */ 616 boolean supportsMultiValueInExpr(); 617 618 /** 619 * Returns whether this Dialect supports the given concurrency type 620 * in combination with the given result set type. 621 * 622 *
The result is similar to 623 * {@link java.sql.DatabaseMetaData#supportsResultSetConcurrency(int, int)}, 624 * except that the JdbcOdbc bridge in JDK 1.6 overstates its abilities. 625 * See bug 1690406. 626 * 627 * @param type defined in {@link java.sql.ResultSet} 628 * @param concurrency type defined in {@link java.sql.ResultSet} 629 * @return true if so; false otherwise 630 */ 631 boolean supportsResultSetConcurrency( 632 int type, 633 int concurrency); 634 635 /** 636 * Returns the maximum length of the name of a database column or query 637 * alias allowed by this dialect. 638 * 639 * @see java.sql.DatabaseMetaData#getMaxColumnNameLength() 640 * 641 * @return maximum number of characters in a column name 642 */ 643 int getMaxColumnNameLength(); 644 645 /** 646 * Returns the database for this Dialect, or 647 * {@link mondrian.spi.Dialect.DatabaseProduct#UNKNOWN} if the database is 648 * not a common database. 649 * 650 * @return Database 651 */ 652 DatabaseProduct getDatabaseProduct(); 653 654 /** 655 * Assembles and returns a string containing any hints that should 656 * be appended after the FROM clause in a SELECT statement, based 657 * on any hints provided. Any unrecognized or unsupported hints will 658 * be ignored. 659 * 660 * @param buf The Stringbuffer to which the dialect-specific syntax 661 * for any relevant table hints may be appended. Must not be null. 662 * @param hints A map of table hints provided in the schema definition 663 */ 664 void appendHintsAfterFromClause( 665 StringBuilder buf, 666 Map<String, String> hints); 667 668 /** 669 * Returns whether this Dialect object can be used for all connections 670 * from the same data source. 671 * 672 *
The default implementation returns {@code true}, and this allows 673 * dialects to be cached and reused in environments where connections are 674 * allocated from a pool based on the same data source.
 675 * 676 *
Data sources are deemed 'equal' by the same criteria used by Java 677 * collections, namely the {@link Object#equals(Object)} and 678 * {@link Object#hashCode()} methods.
 679 * 680 * @see mondrian.spi.DialectFactory#createDialect(javax.sql.DataSource, java.sql.Connection) 681 * 682 * @return Whether this dialect can be used for other connections created 683 * from the same data source 684 */ 685 boolean allowsDialectSharing(); 686 687 /** 688 * Returns whether the database currently permits queries to include in the 689 * SELECT clause expressions that are not listed in the GROUP BY clause. The 690 * SQL standard allows this if the database can deduce that the expression 691 * is functionally dependent on columns in the GROUP BY clause. 692 * 693 *
For example, {@code SELECT empno, first_name || ' ' || last_name FROM 694 * emps GROUP BY empno} is valid because {@code empno} is the primary key of 695 * the {@code emps} table, and therefore all columns are dependent on it. 696 * For a given value of {@code empno}, 697 * {@code first_name || ' ' || last_name} has a unique value. 698 * 699 *
Most databases do not, MySQL is an example of one that does (if the 700 * functioality is enabled). 701 * 702 * @return Whether this Dialect allows SELECT clauses to contain 703 * columns that are not in the GROUP BY clause 704 */ 705 boolean allowsSelectNotInGroupBy(); 706 707 /** 708 * Returns whether this dialect supports "ANSI-style JOIN syntax", 709 * {@code FROM leftTable JOIN rightTable ON conditon}. 710 * 711 * @return Whether this dialect supports FROM-JOIN-ON syntax. 712 */ 713 boolean allowsJoinOn(); 714 715 /** 716 * Informs Mondrian if the dialect supports regular expressions 717 * when creating the 'where' or the 'having' clause. 718 * @return True if regular expressions are supported. 719 */ 720 boolean allowsRegularExpressionInWhereClause(); 721 722 /** 723 * Some databases, like Greenplum, don't include nulls as part 724 * of the results of a COUNT sql call. This allows dialects 725 * to wrap the count expression in something before it is used 726 * in the query. 727 * @param exp The expression to wrap. 728 * @return A valid expression to use for a count operation. 729 */ 730 String generateCountExpression(String exp); 731 732 /** 733 * Must generate a String representing a regular expression match 734 * operation between a string literal and a Java regular expression. 735 * The string literal might be a column identifier or some other 736 * identifier, but the implementation must presume that it is already 737 * escaped and fit for use. The regular expression is not escaped 738 * and must be adapted to the proper dialect rules. 739 *
Postgres / Greenplum example: 740 *
 741 * generateRegularExpression( 742 * "'foodmart'.'customer_name'", "(?i).*oo.*") -> 743 * 'foodmart'.'customer_name' ~ "(?i).*oo.*" 744 *
 745 *
Oracle example: 746 *
 747 * generateRegularExpression( 748 * "'foodmart'.'customer_name'", ".*oo.*") -> 749 * REGEXP_LIKE('foodmart'.'customer_name', ".*oo.*") 750 *
 751 * 752 *
Dialects are allowed to return null if the dialect cannot 753 * convert that particular regular expression into something that 754 * the database would support.
 755 * 756 * @param source A String identifying the column to match against. 757 * @param javaRegExp A Java regular expression to match against. 758 * @return A dialect specific matching operation, or null if the 759 * dialect cannot convert that particular regular expression into 760 * something that the database would support. 761 */ 762 String generateRegularExpression( 763 String source, 764 String javaRegExp); 765 766 /** 767 * Returns a list of statistics providers for this dialect. 768 * 769 *
The default implementation looks for the value of the property 770 * {@code mondrian.statistics.providers.PRODUCT} where product is the 771 * current dialect's product name (for example "MYSQL"). If that property 772 * has no value, looks at the property 773 * {@code mondrian.statistics.providers}. The property value should be 774 * a comma-separated list of names of classes that implement the 775 * {@link StatisticsProvider} interface. For each statistic required, 776 * Mondrian will call the method each statistics provider in turn, until one 777 * of them returns a non-negative value.
 778 */ 779 List<StatisticsProvider> getStatisticsProviders(); 780 781 /** 782 *
Chooses the most appropriate type for accessing the values of a 783 * column in a result set for a dialect.
 784 * 785 *
Dialect-specific nuances involving type representation should be 786 * encapsulated in implementing methods. For example, if a dialect 787 * has implicit rules involving scale or precision, they should be 788 * handled within this method so the client can simply retrieve the 789 * "best fit" SqlStatement.Type for the column.
 790 * 791 * @param metadata Results set metadata 792 * @param columnIndex Column ordinal (0-based) 793 * @return the most appropriate SqlStatement.Type for the column 794 */ 795 SqlStatement.Type getType(ResultSetMetaData metadata, int columnIndex) 796 throws SQLException; 797 798 /** 799 * Enumeration of common database types. 800 * 801 *
Branching on this enumeration allows you to write code which behaves 802 * differently for different databases. However, since the capabilities of 803 * a database can change between versions, it is recommended that 804 * conditional code is in terms of capabilities methods in 805 * {@link mondrian.spi.Dialect}. 806 * 807 *
Because there are so many differences between various versions and 808 * ports of DB2, we represent them as 3 separate products. If you want to 809 * treat them all as one product, note that the {@link #getFamily()} method 810 * for {@link #DB2_AS400} and {@link #DB2_OLD_AS400} returns {@link #DB2}. 811 */ 812 enum DatabaseProduct { 813 ACCESS, 814 UNKNOWN, 815 DERBY, 816 DB2_OLD_AS400, 817 DB2_AS400, 818 DB2, 819 FIREBIRD, 820 GREENPLUM, 821 HIVE, 822 HSQLDB, 823 IMPALA, 824 INFORMIX, 825 INFOBRIGHT, 826 INGRES, 827 INTERBASE, 828 LUCIDDB, 829 MSSQL, 830 MONETDB, 831 NETEZZA, 832 NEOVIEW, 833 ORACLE, 834 POSTGRESQL, 835 REDSHIFT, 836 MYSQL, 837 SQLSTREAM, 838 SYBASE, 839 TERADATA, 840 VERTICA, 841 VECTORWISE; 842 843 /** 844 * Return the root of the family of products this database product 845 * belongs to. 846 * 847 *
For {@link #DB2_AS400} and {@link #DB2_OLD_AS400} returns 848 * {@link #DB2}; for all other database products, returns the same 849 * product. 850 * 851 * @return root of family of database products 852 */ 853 public DatabaseProduct getFamily() { 854 switch (this) { 855 case DB2_OLD_AS400: 856 case DB2_AS400: 857 return DB2; 858 default: 859 return this; 860 } 861 } 862 } 863 864 /** 865 * Datatype of a column. 866 */ 867 enum Datatype { 868 String { 869 public void quoteValue( 870 StringBuilder buf, Dialect dialect, String value) 871 { 872 dialect.quoteStringLiteral(buf, value); 873 } 874 }, 875 876 Numeric { 877 public void quoteValue( 878 StringBuilder buf, Dialect dialect, String value) 879 { 880 dialect.quoteNumericLiteral(buf, value); 881 } 882 883 public boolean isNumeric() { 884 return true; 885 } 886 }, 887 888 Integer { 889 public void quoteValue( 890 StringBuilder buf, Dialect dialect, String value) 891 { 892 dialect.quoteNumericLiteral(buf, value); 893 } 894 895 public boolean isNumeric() { 896 return true; 897 } 898 }, 899 900 Boolean { 901 public void quoteValue( 902 StringBuilder buf, Dialect dialect, String value) 903 { 904 dialect.quoteBooleanLiteral(buf, value); 905 } 906 }, 907 908 Date { 909 public void quoteValue( 910 StringBuilder buf, Dialect dialect, String value) 911 { 912 dialect.quoteDateLiteral(buf, value); 913 } 914 }, 915 916 Time { 917 public void quoteValue( 918 StringBuilder buf, Dialect dialect, String value) 919 { 920 dialect.quoteTimeLiteral(buf, value); 921 } 922 }, 923 924 Timestamp { 925 public void quoteValue( 926 StringBuilder buf, Dialect dialect, String value) 927 { 928 dialect.quoteTimestampLiteral(buf, value); 929 } 930 }; 931 932 /** 933 * Appends to a buffer a value of this type, in the appropriate format 934 * for this dialect. 935 * 936 * @param buf Buffer 937 * @param dialect Dialect 938 * @param value Value 939 */ 940 public abstract void quoteValue( 941 StringBuilder buf, 942 Dialect dialect, 943 String value); 944 945 /** 946 * Returns whether this is a numeric datatype. 947 * 948 * @return whether this is a numeric datatype. 949 */ 950 public boolean isNumeric() { 951 return false; 952 } 953 } 954} 955 956// End Dialect.java


Confident skin starts here!
No drugstore product is this customized. We use your photos, your history, and your goals to pick powerful active ingredients just for you. From occasional spots to full-on breakouts, our simple once-a-day cream has you covered.


--- status: "draft" title: "Disabled" text: Disabled input elements are unusable and can not be clicked. This prevents a user from interacting with the input element until another action is complete. Disabled input elements in a form will not be submitted. ---


We define the ultimate Good as a world where no one is The Other and Everyone Belongs. The Coalition for Good (CfG) is a membership alliance of individuals, networks, organizations and businesses united by our values and vision which benefit the Common Good.
Dedication to the Common Good and the transformation we need won’t happen without a commitment to inclusivity + belonging. Diversity isn’t enough. Being “not racist” isn’t enough. It’s time to take a definitive stance, not only for inclusivity, diversity and belonging but against racism, white supremacy and the many manifestations of bigotry.
It’s time for moral courage. A clear, visible Anti-Black Racism + Anti-Indigenous Racism + Anti-POC Racism + Anti-Othering position is vital.
A world with more caring, just|equitable, inclusive and thus sustainable communities and societies is our vision. We want the planet to be a No-Othering Zone. Our mission is to facilitate cultural, systemic transformation toward our shared vision via creation of collaborative spaces, platforms and projects.
Doing the work to create spaces and systems that are founded upon genuine care for one another and a commitment to Anti-Racism + Anti-Othering is our priority.
We’re like a Chamber of Commons, building an Ecosystem for Good.
The Coalition for Good shall guide the way to that more caring, just, inclusive world, led by those who have been most impacted by racism and othering.


Menu
CovidData
Covid Data Dashboard
Close Menu
Data Overview
World Maps
Data Vaccinations
Data Charts
Data France
News about Covid
About
World maps reported Cases by Country, Territory, or Conveyance.
Double click on the map to zoom or use control buttons. Right click on the map for context menu.
Active & Critical Cases Map
Global Cumulative Cases Map
Covid-19 World map of actual active & critical cases. Last update:
Covid-19 World map of cumulative global cases since the beginning of the pandemic. Last update:


See: Description
| Interface | Description |
|---|---|
| Bag |
Defines a collection that counts the number of times an object appears in
the collection.
|
| BidiMap |
Defines a map that allows bidirectional lookup between key and values.
|
| BoundedCollection |
Defines a collection that is bounded in size.
|
| BoundedMap |
Defines a map that is bounded in size.
|
| Buffer |
Defines a collection that allows objects to be removed in some well-defined order.
|
| Closure |
Defines a functor interface implemented by classes that do something.
|
| Factory |
Defines a functor interface implemented by classes that create objects.
|
| IterableMap |
Defines a map that can be iterated directly without needing to create an entry set.
|
| KeyValue |
Defines a simple key value pair.
|
| MapIterator |
Defines an iterator that operates over a
Map . |
| MultiMap |
Defines a map that holds a collection of values against each key.
|
| OrderedBidiMap |
Defines a map that allows bidirectional lookup between key and values
and retains and provides access to an ordering.
|
| OrderedIterator |
Defines an iterator that operates over an ordered collection.
|
| OrderedMap |
Defines a map that maintains order and allows both forward and backward
iteration through that order.
|
| OrderedMapIterator |
Defines an iterator that operates over an ordered
Map . |
| Predicate |
Defines a functor interface implemented by classes that perform a predicate
test on an object.
|
| PriorityQueue | Deprecated
Replaced by the Buffer interface and implementations in buffer subpackage.
|
| ResettableIterator |
Defines an iterator that can be reset back to an initial state.
|
| ResettableListIterator |
Defines a list iterator that can be reset back to an initial state.
|
| SortedBag |
Defines a type of
Bag that maintains a sorted order among
its unique representative members. |
| SortedBidiMap |
Defines a map that allows bidirectional lookup between key and values
and retains both keys and values in sorted order.
|
| Transformer |
Defines a functor interface implemented by classes that transform one
object into another.
|
| Unmodifiable |
Marker interface for collections, maps and iterators that are unmodifiable.
|
| Class | Description |
|---|---|
| ArrayStack |
An implementation of the
Stack API that is based on an
ArrayList instead of a Vector , so it is not
synchronized to protect against multi-threaded access. |
| BagUtils | |
| BeanMap | Deprecated
Identical class now available in commons-beanutils (full jar version).
|
| BeanMap.MyMapEntry |
Map entry used by
BeanMap . |
| BinaryHeap | Deprecated
Replaced by PriorityBuffer in buffer subpackage.
|
| BoundedFifoBuffer | Deprecated
Moved to buffer subpackage.
|
| BufferUtils |
Provides utility methods and decorators for
Buffer instances. |
| ClosureUtils |
ClosureUtils provides reference implementations and utilities
for the Closure functor interface. |
| CollectionUtils |
Provides utility methods and decorators for
Collection instances. |
| ComparatorUtils |
Provides convenient static utility methods for
Comparator
objects. |
| CursorableLinkedList | Deprecated
Use new version in list subpackage, which has been rewritten
and now returns the cursor from the listIterator method.
|
| DefaultMapBag | Deprecated
Moved to bag subpackage as AbstractMapBag.
|
| DefaultMapEntry | Deprecated
Use the version in the keyvalue subpackage.
|
| DoubleOrderedMap | Deprecated
Replaced by TreeBidiMap in bidimap subpackage.
|
| EnumerationUtils |
Provides utility methods for
Enumeration instances. |
| ExtendedProperties |
This class extends normal Java properties by adding the possibility
to use the same key many times concatenating the value strings
instead of overwriting them.
|
| FactoryUtils |
FactoryUtils provides reference implementations and utilities
for the Factory functor interface. |
| FastArrayList |
A customized implementation of
java.util.ArrayList designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes. |
| FastHashMap |
A customized implementation of
java.util.HashMap designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes. |
| FastTreeMap |
A customized implementation of
java.util.TreeMap designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes. |
| HashBag | Deprecated
Moved to bag subpackage and rewritten internally.
|
| IteratorUtils |
Provides static utility methods and decorators for
Iterator
instances. |
| ListUtils |
Provides utility methods and decorators for
List instances. |
| LRUMap | Deprecated
Moved to map subpackage.
|
| MapUtils | |
| MultiHashMap | Deprecated
Class now available as MultiValueMap in map subpackage.
|
| PredicateUtils |
PredicateUtils provides reference implementations and utilities
for the Predicate functor interface. |
| ProxyMap | Deprecated
Moved to map subpackage as AbstractMapDecorator.
|
| ReferenceMap | Deprecated
Moved to map subpackage.
|
| SequencedHashMap | Deprecated
Replaced by LinkedMap and ListOrderedMap in map subpackage.
|
| SetUtils | |
| StaticBucketMap | Deprecated
Moved to map subpackage.
|
| SynchronizedPriorityQueue | Deprecated
PriorityQueue is replaced by the Buffer interface, see buffer subpackage.
|
| TransformerUtils |
TransformerUtils provides reference implementations and
utilities for the Transformer functor interface. |
| TreeBag | Deprecated
Moved to bag subpackage and rewritten internally.
|
| UnboundedFifoBuffer | Deprecated
Moved to buffer subpackage.
|
| Exception | Description |
|---|---|
| BufferOverflowException |
The BufferOverflowException is used when the buffer's capacity has been
exceeded.
|
| BufferUnderflowException |
The BufferUnderflowException is used when the buffer is already empty.
|
| FunctorException |
Runtime exception thrown from functors.
|
This package contains the interfaces and utilities shared across all the subpackages of this component.
The following collection implementations are provided in the package:
Copyright © 2001–2015 The Apache Software Foundation. All rights reserved.


Building the documentation¶
Note
You can skip this section if you just want to get REGoth running. This guide is only relevant if you want to contribute to this documentation.
This documentation is written as reStructuredText and built using
Sphinx.
See here
for a quick reference of the rst
syntax. You will also need to have Doxygen and PlantUML
installed (see Building REGoth, Development dependencies).
pip packages¶
The following pip
packages are required:
$ pip install sphinx breathe sphinx_rtd_theme sphinxcontrib-plantuml
As usual with Python, it is recommended to use a virtual environment.
Building¶
With a CMake project generated, run this from within the build
directory:
$ cmake --build . --target REGoth_docs
This will generate the documentation as HTML into build/docs-source/html
. Just open
build/docs-source/html/index.html
in your browser to view the documentation locally. To update
GitHub-pages, copy the contents of that directory into the docs
directory at the repository
root.
Modifying an existing chapter¶
Simply go to docs-source/content
and open one of the .rst
-files with a text editor of your
choice.
Adding a new chapter¶
To add a new chapter you will have to:
Create a new
.rst
-file:docs-source/content/<your-chapter>.rst
Add the new
.rst
-file todocs-source/index.rst


We propose Youtube video classification at scale, leveraging a dataset of over 8 million videos
with high throughput computing and large data handling system design. The project requires training
on 1.5 terabytes of video and audio files to then predict a video type from several thousand labels. Our
solution uses two bidirectional-LSTM networks, one for audio and one for video, trained on a Spark-based
sitting atop Hadoop YARN and enabled by Elephas: a library that enables training Tensorflow models
in Spark. The infrastructure used consists of a custom cluster of m4.xlarge instances on AWS using Amazon
Machine Images to spin-up nodes with the correct software dependencies. We found this approach produced
reliable systemic speedup and effective classification with our final model.
We have learned many lessons through this project, especially in provisioning our custom Elastic Map Reduce
cluster, as well as in building various software dependencies: Tensorflow-Spark connector for reading
TFRecord files, Amazon-flavored Linux, Apache Maven, and getting all of our various components to be
version-compatible (e.g. Scala, Java versions with PySpark, Tensorflow-Spark and Amazon Linux versions).
We faced many issues in provisioning the cluster as a result of the growing complexity that so many software
dependencies adds to the problem, especially when there are non-backward-compatible components (e.g. PySpark
with Scala).
In the future, we would recommend not using Amazon Machine Images (AMIs) for provisioning, and instead bundling
the Python-based dependencies into jar files (a method which we found was possible only after the fact). This
would certainly save much time as there are many specific "gotchas" that are required for tackling the AMI
method successfully (EBS volume configuration, must be Amazon Linux, etc.). On the positive side, we found that
asynchronous weight updates can be parallelized highly effectively, and we actually achieved superlinear speedup
with this method. Future work may involve training more complex models (e.g. multiple input models), or
implementing alternative parallel Stochastic Gradient Descent schemes (e.g. Baidu's proposed Ring AllReduce).
We hope that you can learn from our work and the particular method we employed to deploy Tensorflow model training
on a massive dataset by utilizing Spark sitting atop a Hadoop-based elastic cluster. Please check out the source
code here.


hulu
Businessmodel of Hulu
Customer Segments
Hulu primarily serves mass market consumers who wish to have on-demand access to quality television programming and movies from a variety of sources. Recent reports estimate that the Company has around 9 million individual subscribers in the US. The service is not available internationally.
According to reports within the advertising sector, around 82% of Hulu’s users are aged between 18 and 49, with 75% of users viewing content via a web-connected TV.
Hulu also includes advertisers and agencies among its customers providing a large, captive audience for their advertising content in the form of un-skippable ads.
Value Propositions
Hulu’s streaming service enables users to view premium television and movie content on-demand, via any device and in any location with an internet connection. This convenience and flexibility is the Company’s greatest value to consumers.
What sets the Company apart from its competitors, however, notably Netflix and Amazon Instant Video, is its content. Hulu is the only service that provides access to recent programms, including episodes from the current, airing seasons of various shows. This includes ‘day after rights’ that allow Hulu to stream episodes on its Hulu Plus service that premiered on television just the day before.
Hulu also offers original programms from big names such as JJ Abrams, Stephen King and Billy Eichner, as well as streaming exclusives that are not available elsewhere, including the Wayward Pines, Empire and South Park series. Hulu is also of value to advertisers, expanding their audience and allowing them to target specific demographics.
Channels
Hulu is available via its mobile and desktop websites at www.hulu.com. The Company also provides a range of apps for mobile phones and tablets covering the iOS, Android and Windows Phone operating systems, and can be accessed via smart televisions, gaming consoles, set-top boxes and blu-ray players.
Customer Relationships
Access to Hulu’s streaming platform is entirely self-service. Subscriptions can be purchased, managed and altered through the Company’s website, as well as through its various apps. Users are able to access video content immediately following completion of the registration and billing process. No interaction with Hulu representatives is required.
The platform also has some automated functionality, including viewing suggestions based on user viewing histories. Hulu provides technical assistance to its users in the form of troubleshooting pages, set-up guides and contact forms via the online Hulu Help Centre.
The Company also interacts with its users, keeping them up to date with the platform’s developments, via its Twitter, Facebook, Tumblr, Youtube, Instagram and Google+ accounts.
Key Activities
Hulu primarily provides online television and movie streaming services to the mass consumer market, through partnerships with a range of content providers. It also offers content distribution options, such as commercial media feeds and individual embeddable players, and enables consumers to share content on their personal websites, social networking profiles, and blogs through embed codes.
Hulu also serves advertisers and agencies with a range of ad solutions that enable companies to associate their brands with specific video content and reach their target demographics more effectively. The Company additionally provides advertisers and marketers with ancillary consultancy services relating to research, reporting, insights, and analytics services.
Key Partners
Hulu’s key partners are its content providers, distribution partners and advertising partners. The Company has more than 500 content partners, comprising high-profile production companies, movie studios and televisions networks, including NBC Universal, Comedy Central, BBC, Fox, Showtime, VH1 and ABC.
Hulu also collaborates with around 2,000 advertising partners – comprising advertising agencies and big brand companies – to provide appropriate commercials to its user base. Advertising partners can sponsor seasonal tentpoles, such as Summer TV on Hulu and Hulu for the Holidays, as well as thematically grouped content, including Huluween and Black Friday/Cyber Monday, and can collaborate with the Company through local advertising and targeted advertising solutions.
Hulu also entered into a recent partnership with electronics company Samsung to provide a virtual reality app that can be accessed via the Oculus-powered Samsung Gear Virtual Reality platform.
Key Resources
Hulu’s key resources are its streaming platform, its content and its partnerships. The Company’s content in particular is responsible for much of the platform’s unique value in an increasingly competitive streaming market. This includes Hulu’s original content, its exclusive streaming content and its collaborations with content providers.
The Company’s advertising partners also play a key role within its business model, accounting for a significant proportion of its annual revenue.
Cost Structure
Hulu’s principal costs relate to the development and maintenance of its streaming platform, its IT infrastructure, and its management of content partnerships. Hulu pays its content providers in the form of licensing fees for content, shares much of its advertising revenue with its content partners.
The Company also has revenue sharing agreements with its distribution partners. In addition, Hulu incurs costs relating to its operation of a network of servers and data centres.
Revenue Streams
Hulu makes money through the sale of service subscriptions and the generation of advertising revenue. Subscriptions currently account for a little over half of Hulu’s annual revenue, and is expected to comprise a growing proportion of the Company’s revenue over the coming years.
Hulu offers two subscription packages. The first is priced at $7.99 per month and comes with a limited amount of advertising within its programming. The Company’s premium subscription package costs $11.99 per month and is completely ad-free. Hulu’s ad revenue is shared with its content providers, who take a 70% share of all advertising revenue. The Company also shares a small proportion of its revenue with its distribution partners.
In 2015 Hulu reportedly brought in around $1.6 billion in annual revenue.


Main interface
Much like [connect][connect] where you have a simple interface for all middleware, core.io modules all have to conform to a simple interface.
Each module has to provide an init
function which will take two arguments; context
, and config
.
context
is an instance of a core.io application, and config
is the configuration object for that module.
Inside the init
function is where you would perform all the wiring needed for the module to integrate with your application. Some modules will extend the application by providing new functionality. See extending context for more information and examples.
init
acts as a middle tier between core.io and external libraries.
module.exports.init = function(context, config) {
const repl = require('poke-repl');
context.provide('repl', repl);
};
core.io does not pollute the global
namespace, the intended way to access the functionality is by keeping a reference of the context
object if it's necessary.
Dependencies
If your module has dependencies most of the time core.io can handle those. It can wait for dependencies
Promises
Extending context
The core.io application context exposes a function to provide new functionality through modules.
context.provide(name, capability);
Modules
A Node.js package is a convenient way to organize, distribute and reuse source code between Node.js programs.
A Node.js module is anything that can be loaded with require
.
core.io modules are intended to encapsulate logic in a way that can be reused between projects, in that sense core.io modules are similar to [npm packages][npm-packages].
Perhaps the modules contain logic specific to your application since modules are used to integrate packages into the application. You could think about modules as plugins or middleware.
Defining a core.io Module
core.io modules need to conform to a simple interface.
- They need to expose an
init
function. - The init function will be given two arguments:
context
andconfig
.
For the most part, that's it. There are more options like exporting an alias
or a priority
property.
Modules Names
-
sanitizeName
: It ensures the resulting string is a valid JavaScript variable name. -
alias
: Modules can export analias
property that will be used instead of the filename. -
moduleid
: If no module id is provided in the configuration file, the sanitized name will be used.
Conventions around modules names:
- configuration file: matching configuration files will de passed to module.
- child logger: receives the name of the module.
Core Modules
Core modules are optional and can be replaced by any module as long as it provides the same interface.
Some are optional, like the REPL module. If you don't need or don't want a REPL you can remove it from the list of coremodules
using the configuration object that you pass to the application instance during the initialization of your program, in the entry point file.
The most likely scenario is that you might want to enable it during development but not on production.
Modules
A module adds a specific feature to an existing application context, providing a means to extend your application with specific behavior for a given project in an encapsulated way.
All modules are stored in the modules folder of your application project directory.
thus maximizing the amount of code you can reuse between applications.
Modules follow a simple convention: they should export an init function that take an instance of the application context
and a configuration object as arguments.
Modules should have a name that is unique in your application. This name will be used to access the module later on from other parts of your application. By default the module loader will infer this name from the file that registers the module.
Your module does not need to return anything, but if it does it should be either an object or a Promise.
If you return an object, you then will be able to access it through the application instance- app[moduleName]
.
If you return a Promise
instance, then once it resolves the process is the same.
Once the module is registered, the app instance will emit an event: moduleName + '.' + config.app.registerReadyEvent
, in the case for the core logger module and using the default value for registerReadyEvent
the event type would be logger.registered
.
Once all core plugins are loaded, the application emits the event coreplugins.registered
.
Module autoloading
Module commands
If a module contains a directory named commands all files in the directory will be autoloaded and registered as commands.
In order for this to work you need to set the property autoloadModulesCommands
to true
in the applications configuration file.
Module instantiation
The modules instantiation follows a simple registration process.
- users module:
./modules/users.js
module.exports.init = function(core, config) {
...
return users;
};
core.once('users.registered', function() {
});
Modules configuration
Configuration files located in the config/
folder of projects will be merged together in a single object, which will be available at runtime as a property of your application instance, i.e. context.config
.
The top-level keys on the context.config
(i.e. context.config.repl
) object correspond to a particular configuration file name under your config/
directory (i.e. config/repl.js
). Most individual configuration files are specific to a module, with the exception of config/app.js
which should hold options for your current application, like the application's name, it's base directory, environment in run under, etc.
The intention of these files is to provide modules with configuration options. When a module is loaded, it will be called with the application's instance and a config
top-level key that matches the module's name.


You seem to have caught us with our pants down. This part of the site is still under construction. Please check back soon!
Contact<EMAIL_ADDRESS>#INSERT TEXT HERE
#INSERT TEXT HERE
Contact<EMAIL_ADDRESS>Contact<EMAIL_ADDRESS>#INSERT TEXT HERE
Contact: auri@yinchannel.moe


Contents:
Python library for using Google Geocoding API V3.
Interface for interacting with Google’s Geocoding V3’s API. http://code.google.com/apis/maps/documentation/geocoding/
If you have a Google Maps Premier account, you can supply your client_id and private_key and the Geocoder will make the request with a properly signed url
Represents the data for a single result returned by the google maps api. Allows you to access the data from the response using attributes instead of diving deep into the returned dictionary structure.
You can create aliases for the default ‘address_components’ of the response by settings the attr_mapping field to a dict of your mapping.:
attr_mapping = {'state': 'administrative_area_level_1'}
Base class for errors in the ggeocoder module.
Methods of the Geocoder raise this when the Google Maps API returns a status of anything other than ‘OK’.
See http://code.google.com/apis/maps/documentation/geocoding/index.html#StatusCodes for status codes and their meanings.


Id
Text
Rating
Actions
{% for comment in comments %}
{{loop.index}}
{{comment.text}}
Delete
{% endfor %}


${listing.title} USD ${listing.address.total_value | usdFormat}
${listing.description}
${listing.description}
By clicking, "Yes" you acknowledge that comitting to this task does not guarantee payment. There are 0 people currently working on this task who could finish it before you do.
If you would like to contribute to the bounty of this task, please enter an amount of Litecoin (LTC) in the box below that you would like to contribute.


Based in Athens, Greece. Graduated in Computer Science Department from the University Of Crete (CSD). I am an urban traveller, passionate about good movies, tv-series. I like to think I am a mix of the places I have lived in and the people I have met along the way. And so it is my way of working, easy going, honest, down to earth, never "overselling it" and a good communicator.
Despite being "techno-geek" since my early teen years, i was not so much interested in the web development until i got in the university and become truly interested in it. Especially when i created my first stable web application for my thesis written in ReactJS-NodeJS-MongoDB , i decided that i want to dive into the web technologies and find a job that will give me the experience that i needed. Everything became easier when the university offered me the opportunity to apply for an internship via the Erasmus program , I jumped to take the chance. All of a sudden, I was in the Netherlands to start my first 6-month internship as a Full- Stack Developer at a company named Pluxbox. Pluxbox is a cloud-based software platform built specifically for the radio industry and around the day-to-day working processes involved. It brings together every element that a production team needs in a single location – enabling them to work in harmony. I had the chance to work both on this platform and on some other products, ordered by different clients, diving into Front-End technologies like HTML, CSS, Javascript, Typescript but also into Back-End tecnologies like NodeJS, GraphQL, MongoDB and Docker, Kubernetes.


Contact Harbour Control for advice on where to berth. South Port Bluff Harbour Radio, VHF Ch 16. Contact authorities not less than 48 hours prior to estimated time of arrival. Taupo Maritime Radio on 4125Khz or 6215Khz or VHFCh 16.


@(target: String, issues: List[service.IssuesService.IssueInfo], page: Int, openCount: Int, fixedCount: Int, closedCount: Int, condition: service.IssuesService.IssueSearchCondition, collaborators: List[String] = Nil, milestones: List[model.Milestone] = Nil, labels: List[model.Label] = Nil, repository: Option[service.RepositoryService.RepositoryInfo] = None, hasWritePermission: Boolean = false)(implicit context: app.Context) @import context._ @import view.helpers._ @import service.IssuesService.IssueInfo @if(condition.nonEmpty){ Clear current search query, filters, and sorts } @if(openCount == 0 && closedCount == 0) {
Issues are used to track todos, bugs, feature requests, and more. As issues are created, they'll appear here in a searchable and filterable list. To get started, you should create an issue.


Dynamic Programming (Policy Iteration, Value Iteration), SARSA, Q-Learning
LINK@KoreaTech
Febraury, 14, 2019
Email:
link.koreatech at gmail.com
This site is made by using the source codes shared from the site,
REINFORCEjs
.
Policy Iteration
Start/Pause (Toggle)
Stop
Reset
Sum of All State Values:
0
Difference of Sum of All State Values:
-1
Status:
RESET
Discount Factor (gamma): 0.75
Iteration:
-1
Value Iteration
Start/Pause (Toggle)
Stop
Reset
Sum of All State Values:
0
Difference of Sum of All State Values:
-1
Status:
RESET
Discount Factor (gamma): 0.75
Iteration:
-1
SARSA
Start/Pause (Toggle)
Stop
Reset
Sum of all state values:
-1
Total number of steps over all episodes:
-1
Status:
RESET
Epsilon:
0.2
Discount Factor (γ): 0.75
Initial epsilon value for ε-greedy policy (ε): 0.2
Epsilon decay rate (η): 0.02
Learning rate (α): 0.1
Sum of each step's reward over episodes:
Episode:
0
Q-learning
Start/Pause (Toggle)
Stop
Reset
Sum of all state values:
-1
Total number of steps over all episodes:
-1
Status:
RESET
Epsilon:
0.2
Discount Factor (γ): 0.75
Initial epsilon value for ε-greedy policy (ε): 0.2
Epsilon decay rate (η): 0.02
Learning rate (α): 0.1
Sum of each step's reward over episodes:
Episode:
0


|
lubyk
0.5
|
#include <Poller.h>
Public Member Functions | |
| Poller (int reserve=8) | |
| ~Poller () | |
| bool | poll (float timeout) |
| LuaStackSize | events (lua_State *L) |
| int | add (int fd, int events) |
| int | add (zmq::Socket *sock, int events) |
| void | modify (int idx, int events, lua_State *L) |
| void | remove (int idx) |
| int | count () |
| LuaStackSize | idxToPos (int idx, lua_State *L) |
| LuaStackSize | posToIdx (int pos, lua_State *L) |
| LuaStackSize | posToFd (int pos, lua_State *L) |
| LuaStackSize | posToEvent (int pos, lua_State *L) |
Static Public Attributes | |
| static pthread_key_t | sThisKey |
Private Member Functions | |
| int | addItem (int fd, void *socket, int events) |
| void | setupInterruptHook () |
Static Private Member Functions | |
| static void | sInterrupted (int i) |
Private Attributes | |
| zmq_pollitem_t * | pollitems_ |
| int | pollitems_size_ |
| int * | idx_to_pos_ |
| int * | pos_to_idx_ |
| int | used_count_ |
| int | event_count_ |
| TimeRef | time_ |
| bool | interrupted_ |
ZeroMQ polling helper.
| zmq::Poller::Poller | ( | int | reserve = 8 | ) | [inline] |
| int zmq::Poller::add | ( | zmq::Socket * | sock, |
| int | events | ||
| ) | [inline] |
Definition at line 219 of file Poller.h.
References zmq::Socket::socket_.
| int zmq::Poller::addItem | ( | int | fd, |
| void * | socket, | ||
| int | events | ||
| ) | [inline, private] |
| LuaStackSize zmq::Poller::events | ( | lua_State * | L | ) | [inline] |
| LuaStackSize zmq::Poller::idxToPos | ( | int | idx, |
| lua_State * | L | ||
| ) | [inline] |
| void zmq::Poller::modify | ( | int | idx, |
| int | events, | ||
| lua_State * | L | ||
| ) | [inline] |
Modify an item's events by its id.
Definition at line 225 of file Poller.h.
References zmq::Socket::fd(), idx, and zmq::Socket::socket_.
| bool zmq::Poller::poll | ( | float | timeout | ) | [inline] |
Polls for new events and ensures that if we timeout, this is done as precisely as possible (pads with nanosleep).
| timeout | in milliseconds. |
Definition at line 138 of file Poller.h.
References lubyk::Thread::millisleep(), and start.
| LuaStackSize zmq::Poller::posToEvent | ( | int | pos, |
| lua_State * | L | ||
| ) | [inline] |
| LuaStackSize zmq::Poller::posToFd | ( | int | pos, |
| lua_State * | L | ||
| ) | [inline] |
| LuaStackSize zmq::Poller::posToIdx | ( | int | pos, |
| lua_State * | L | ||
| ) | [inline] |
| void zmq::Poller::remove | ( | int | idx | ) | [inline] |
| static void zmq::Poller::sInterrupted | ( | int | i | ) | [inline, static, private] |
Definition at line 353 of file Poller.h.
References interrupted_.
int zmq::Poller::event_count_ [private] |
int* zmq::Poller::idx_to_pos_ [private] |
bool zmq::Poller::interrupted_ [private] |
We set this to true when we receive a SIGINT. This enables poll to return false.
Definition at line 87 of file Poller.h.
Referenced by sInterrupted().
zmq_pollitem_t* zmq::Poller::pollitems_ [private] |
int zmq::Poller::pollitems_size_ [private] |
int* zmq::Poller::pos_to_idx_ [private] |
pthread_key_t zmq::Poller::sThisKey [static] |
TimeRef zmq::Poller::time_ [private] |
int zmq::Poller::used_count_ [private] |


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
ResultSet
object.
PreparedStatement
object's batch of commands.
Statement
object.
ResultSet
object, just after the
last row.
getProcedures
.
getTables
in a SELECT
statement.
SQLException
while autoCommit is true
inidcates
that all open ResultSets are closed, even ones that are holdable.
ResultSet
object, just before the
first row.
Statement
object if both the DBMS and
driver support aborting an SQL statement.
Statement
object if both the DBMS and
driver support aborting an SQL statement.
ResultSet
object.
Statement
object's current list of
SQL commands.
Statement
object's current list of
SQL commands.
Connection
object.
Statement
object.
ResultSet
object.
Statement
object.
Connection
object's database and JDBC resources
immediately instead of waiting for them to be automatically released.
ResultSet
object's database and
JDBC resources immediately instead of waiting for
this to happen when it is automatically closed.
Statement
object's database
and JDBC resources immediately instead of waiting for
this to happen when it is automatically closed.
Connection
object.
Blob
interface.
Clob
interface.
NClob
interface.
SQLXML
interface.
Statement
object for sending
SQL statements to the database.
Statement
object that will generate
ResultSet
objects with the given type and concurrency.
Statement
object that will generate
ResultSet
objects with the given type, concurrency,
and holdability.
ResultSet
object
and from the underlying database.
ResultSet.rowDeleted
.
getMaxRowSize
includes the SQL data types
LONGVARCHAR
and LONGVARBINARY
.
RowId
to the specified object.
PreparedStatement
object,
which may be any kind of SQL statement.
PreparedStatement
object
and returns the ResultSet
object generated by the query.
PreparedStatement
object
and returns the ResultSet
object generated by the query.
ResultSet
object.
PreparedStatement
object,
(JDBC4 clarification:)
which must be an SQL Data Manipulation Language (DML) statement, such as INSERT
, UPDATE
or
DELETE
; or an SQL statement that returns nothing,
such as a DDL statement.
INSERT
,
UPDATE
, or DELETE
statement or an
SQL statement that returns nothing, such as an SQL DDL statement.
Statement
object
should be made available for retrieval.
${system.property}
replaced by the corresponding Java
System Properties.
ResultSet
column label to its
ResultSet
column index.
ResultSet
object.
Array
object and releases the resources that
it holds.
Array
object and releases the resources that
it holds.
Blob
object and releases the resources that
it holds.
Blob
object and releases the resources that
it holds.
Blob
object and releases the resources that
it holds.
Clob
object and releases the resources the resources
that it holds.
Clob
object and releases the resources the resources
that it holds.
Clob
object and releases the resources the resources
that it holds.
ARRAY
value designated
by this
Array
object in the form of an array in the Java
programming language.
ARRAY
value designated by this
Array
object.
ARRAY
value designated by this Array
object, beginning with the
specified index
and containing up to count
successive elements of the SQL array.
ARRAY
value
designated by this Array
object, beginning with the specified
index
and containing up to count
successive elements of the SQL array.
ARRAY
value designated
by this
Array
object in the form of an array in the Java
programming language.
ARRAY
value designated by this
Array
object.
ARRAY
value designated by this Array
object, beginning with the
specified index
and containing up to count
successive elements of the SQL array.
ARRAY
value
designated by this Array
object, beginning with the specified
index
and containing up to count
successive elements of the SQL array.
ARRAY
parameter as an
Array
object in the Java programming language.
ARRAY
parameter as an
Array
object in the Java programming language.
ResultSet
object as an Array
object
in the Java programming language.
ResultSet
object as an Array
object
in the Java programming language.
CLOB
value designated by this Clob
object as an ASCII stream.
CLOB
value designated by this
Clob
object as an ascii stream.
CLOB
value designated by this Clob
object as an ascii stream.
ResultSet
object as
a stream of ASCII characters.
ResultSet
object as a stream of
ASCII characters.
Connection
object.
Array
object.
Array
object.
Array
object.
Array
object.
getBigDecimal(int parameterIndex)
or getBigDecimal(String parameterName)
NUMERIC
parameter as a
java.math.BigDecimal
object with as many digits to the
right of the decimal point as the value contains.
NUMERIC
parameter as a
java.math.BigDecimal
object with as many digits to the
right of the decimal point as the value contains.
ResultSet
object as a
java.math.BigDecimal
with full precision.
ResultSet
object as a
java.math.BigDecimal
with full precision.
BLOB
value designated by this
Blob
instance as a stream.
InputStream
object that contains a partial Blob
value,
starting with the byte specified by pos, which is length bytes in length.
BLOB
value designated by this
Blob
instance as a stream.
InputStream
object that contains a partial Blob
value,
starting with the byte specified by pos, which is length bytes in length.
BLOB
value designated by this
Blob
instance as a stream.
InputStream
object that contains a partial Blob
value,
starting with the byte specified by pos, which is length bytes in length.
ResultSet
object as a stream of
uninterpreted bytes.
ResultSet
object as a stream of uninterpreted
byte
s.
BLOB
parameter as a
Blob
object in the Java programming language.
BLOB
parameter as a
Blob
object in the Java programming language.
ResultSet
object as a Blob
object
in the Java programming language.
ResultSet
object as a Blob
object
in the Java programming language.
BIT
or BOOLEAN
parameter as a
boolean
in the Java programming language.
ResultSet
object as
a boolean
in the Java programming language.
ResultSet
object as
a boolean
in the Java programming language.
TINYINT
parameter
as a byte
in the Java programming language.
TINYINT
parameter as a byte
in the Java programming language.
ResultSet
object as
a byte
in the Java programming language.
ResultSet
object as
a byte
in the Java programming language.
BLOB
value that this Blob
object represents, as an array of
bytes.
BLOB
value that this
Blob
object represents, as an array of bytes.
BLOB
value that this Blob
object represents, as an array of
bytes.
BINARY
or
VARBINARY
parameter as an array of byte
values in the Java programming language.
BINARY
or VARBINARY
parameter as an array of byte
values in the Java
programming language.
ResultSet
object as
a byte
array in the Java programming language.
ResultSet
object as
a byte
array in the Java programming language.
ROWID
designated by this java.sql.RowId
object.
Connection
object's current catalog name.
String
that this database uses as the
separator between a catalog and table name.
java.io.Reader
object in the Java programming language.
java.io.Reader
object in the Java programming language.
CLOB
value designated by this Clob
object as a java.io.Reader
object (or as a stream of
characters).
Reader
object that contains a partial Clob
value, starting
with the character specified by pos, which is length characters in length.
CLOB
value designated by this
Clob
object as a java.io.Reader
object (or
as a stream of characters).
Reader
object that contains a partial Clob
value, starting
with the character specified by pos, which is length characters in length.
CLOB
value designated by this Clob
object as a java.io.Reader
object (or as a stream of
characters).
Reader
object that contains a partial Clob
value, starting
with the character specified by pos, which is length characters in length.
ResultSet
object as a
java.io.Reader
object.
ResultSet
object as a
java.io.Reader
object.
CLOB
parameter as a
java.sql.Clob
object in the Java programming language.
CLOB
parameter as a
Clob
object in the Java programming language.
ResultSet
object as a Clob
object
in the Java programming language.
ResultSet
object as a Clob
object
in the Java programming language.
ResultSet
object.
ResultSet
object.
connect(String,Properties)
method.
connect(String,Properties)
method.
Connection
object
that produced this Statement
object.
Connection
object
that produced this Statement
object.
ResultSet
object.
DATE
parameter as a
java.sql.Date
object.
DATE
parameter as a
java.sql.Date
object, using
the given Calendar
object
to construct the date.
DATE
parameter as a
java.sql.Date
object.
DATE
parameter as a
java.sql.Date
object, using
the given Calendar
object
to construct the date.
ResultSet
object as
a java.sql.Date
object in the Java programming language.
ResultSet
object as
a java.sql.Date
object in the Java programming language.
ResultSet
object as a java.sql.Date
object
in the Java programming language.
ResultSet
object as a java.sql.Date
object
in the Java programming language.
DOUBLE
parameter as a double
in the Java programming language.
DOUBLE
parameter as a double
in the Java programming language.
ResultSet
object as
a double
in the Java programming language.
ResultSet
object as
a double
in the Java programming language.
String
.
Statement
object.
ResultSet
object.
Statement
object.
ResultSet
objects
generated from this Statement
object.
ResultSet
object.
ResultSet
objects
generated from this Statement
object.
FLOAT
parameter
as a float
in the Java programming language.
FLOAT
parameter as a float
in the Java programming language.
ResultSet
object as
a float
in the Java programming language.
ResultSet
object as
a float
in the Java programming language.
Statement
object.
Statement
object.
ResultSet
objects
created using this Connection
object.
ResultSet
object
INTEGER
parameter
as an int
in the Java programming language.
INTEGER
parameter as an int
in the Java programming language.
ResultSet
object as
an int
in the Java programming language.
ResultSet
object as
an int
in the Java programming language.
DataSource
object.
DataSource
object.
BIGINT
parameter
as a long
in the Java programming language.
BIGINT
parameter as a long
in the Java programming language.
ResultSet
object as
a long
in the Java programming language.
ResultSet
object as
a long
in the Java programming language.
GROUP BY
clause.
ORDER BY
clause.
SELECT
list.
ResultSet
object produced by this Statement
object.
ResultSet
object produced by this Statement
object.
ResultSet
object produced by this
Statement
object can contain.
ResultSet
object produced by this
Statement
object can contain.
SELECT
statement.
DatabaseMetaData
object that contains
metadata about the database to which this
Connection
object represents a connection.
ResultSetMetaData
object that contains
information about the columns of the ResultSet
object
that will be returned when this PreparedStatement
object
is executed.
ResultSet
object's columns.
Statement
object's next result, deals with
any current ResultSet
object(s) according to the instructions
specified by the given flag, and returns
true
if the next result is a ResultSet
object.
Statement
object's next result, returns
true
if it is a ResultSet
object, and
implicitly closes any current ResultSet
object(s) obtained with the method getResultSet
.
Statement
object's next result, returns
true
if it is a ResultSet
object, and
implicitly closes any current ResultSet
object(s) obtained with the method getResultSet
.
Statement
object's next result, deals with
any current ResultSet
object(s) according to the instructions
specified by the given flag, and returns
true
if the next result is a ResultSet
object.
java.io.Reader
object in the Java programming language.
java.io.Reader
object in the Java programming language.
ResultSet
object as a
java.io.Reader
object.
ResultSet
object as a
java.io.Reader
object.
NCLOB
parameter as a
java.sql.NClob
object in the Java programming language.
NCLOB
parameter as a
java.sql.NClob
object in the Java programming language.
ResultSet
object as a NClob
object
in the Java programming language.
ResultSet
object as a NClob
object
in the Java programming language.
NCHAR
,
NVARCHAR
or LONGNVARCHAR
parameter as
a String
in the Java programming language.
NCHAR
,
NVARCHAR
or LONGNVARCHAR
parameter as
a String
in the Java programming language.
ResultSet
object as
a String
in the Java programming language.
ResultSet
object as
a String
in the Java programming language.
Object
in the Java programming language.
parameterIndex
and uses map
for the custom
mapping of the parameter value.
Object
in the Java
programming language.
parameterIndex
and will convert from the
SQL type of the parameter to the requested Java data type, if the
conversion is supported.
parameterName
and will convert from the
SQL type of the parameter to the requested Java data type, if the
conversion is supported.
ResultSet
object as an Object
in the Java programming language.
ResultSet
object as an Object
in the Java programming language.
ResultSet
object and will convert from the
SQL type of the column to the requested Java data type, if the
conversion is supported.
ResultSet
object and will convert from the
SQL type of the column to the requested Java data type, if the
conversion is supported.
PreparedStatement.setObject
.
PreparedStatement
object for which this ParameterMetaData
object contains
information.
PreparedStatement
object's parameters.
Statement
object to execute.
Statement
object to execute.
REF(<structured-type>)
parameter as a Ref
object in the Java programming language.
REF(<structured-type>)
parameter as a Ref
object in the Java programming language.
ResultSet
object as a Ref
object
in the Java programming language.
ResultSet
object as a Ref
object
in the Java programming language.
ARRAY
value
designated by this Array
object.
ARRAY
value designated by this Array
object.
index
and contains up to
count
successive elements.
index
and contains up to
count
successive elements.
ARRAY
value
designated by this Array
object.
ARRAY
value designated by this Array
object.
index
and contains up to
count
successive elements.
index
and contains up to
count
successive elements.
ResultSet
object.
ResultSet
object.
ResultSet
objects
generated by this Statement
object.
ResultSet
objects
generated by this Statement
object.
ResultSet
objects.
ResultSet
objects
generated by this Statement
object.
ResultSet
objects
generated by this Statement
object.
ResultSet
objects
generated by this Statement
object.
ResultSet
objects
generated by this Statement
object.
ROWID
parameter as a
java.sql.RowId
object.
ROWID
parameter as a
java.sql.RowId
object.
ResultSet
object as a java.sql.RowId
object in the Java
programming language.
ResultSet
object as a java.sql.RowId
object in the Java
programming language.
ROWID
type,
and if so the lifetime for which a RowId
object remains valid.
Savepoint
object represents.
Savepoint
object represents.
Connection
object's current schema name.
SMALLINT
parameter
as a short
in the Java programming language.
SMALLINT
parameter as a short
in the Java programming language.
ResultSet
object as
a short
in the Java programming language.
ResultSet
object as
a short
in the Java programming language.
SQLException.getSQLState
is X/Open (now known as Open Group) SQL CLI or SQL:2003.
SQL XML
parameter as a
java.sql.SQLXML
object in the Java programming language.
SQL XML
parameter as a
java.sql.SQLXML
object in the Java programming language.
ResultSet
as a
java.sql.SQLXML
object in the Java programming language.
ResultSet
as a
java.sql.SQLXML
object in the Java programming language.
Statement
object that produced this
ResultSet
object.
CHAR
,
VARCHAR
, or LONGVARCHAR
parameter as a
String
in the Java programming language.
CHAR
, VARCHAR
,
or LONGVARCHAR
parameter as a String
in
the Java programming language.
ResultSet
object as
a String
in the Java programming language.
ResultSet
object as
a String
in the Java programming language.
CLOB
value
designated by this Clob
object.
CLOB
value designated by this Clob
object.
CLOB
value
designated by this Clob
object.
TIME
parameter as a
java.sql.Time
object.
TIME
parameter as a
java.sql.Time
object, using
the given Calendar
object
to construct the time.
TIME
parameter as a
java.sql.Time
object.
TIME
parameter as a
java.sql.Time
object, using
the given Calendar
object
to construct the time.
ResultSet
object as
a java.sql.Time
object in the Java programming language.
ResultSet
object as
a java.sql.Time
object in the Java programming language.
ResultSet
object as a java.sql.Time
object in the Java programming language.
ResultSet
object as a java.sql.Time
object
in the Java programming language.
TIMESTAMP
parameter as a java.sql.Timestamp
object.
TIMESTAMP
parameter as a
java.sql.Timestamp
object, using
the given Calendar
object to construct
the Timestamp
object.
TIMESTAMP
parameter as a
java.sql.Timestamp
object.
TIMESTAMP
parameter as a
java.sql.Timestamp
object, using
the given Calendar
object to construct
the Timestamp
object.
ResultSet
object as
a java.sql.Timestamp
object in the Java programming language.
ResultSet
object as
a java.sql.Timestamp
object in the Java programming language.
ResultSet
object as a java.sql.Timestamp
object
in the Java programming language.
ResultSet
object as a java.sql.Timestamp
object
in the Java programming language.
Connection
object's current
transaction isolation level.
ResultSet
object.
Map
object associated with this
Connection
object.
getCharacterStream
in place of
getUnicodeStream
getCharacterStream
instead
ResultSet
object or there are no more results, -1
is returned.
ResultSet
object or there are no more results, -1
is returned.
DATALINK
parameter as a
java.net.URL
object.
DATALINK
parameter as a
java.net.URL
object.
ResultSet
object as a java.net.URL
object in the Java programming language.
ResultSet
object as a java.net.URL
object in the Java programming language.
Connection
object.
Statement
object.
ResultSet
object.
Statement
object.
RowId
object.
ResultSet
object and into the database.
ResultSet.rowInserted
.
ResultSet
object.
ResultSet
object.
Connection
object has been
closed.
Statement
object has been closed.
ResultSet
object has been closed.
Statement
object has been closed.
JDBCBlobFile.free()
.
JDBCClobFile.free()
.
ResultSet
object.
ResultSet
object.
Statement
is poolable or not.
Statement
is poolable or not.
Connection
object is in read-only mode.
ARRAY
.ARRAY
.BLOB
value.CLOB
type.JDBCClobFile((String)null)
.
JDBCClobFile(file,null)
.
Connection
to an HSQLDB
Database
.
INTERNAL
Connection
,
using the specified SessionInterface
.
DataSource
object represents.JDBCDataSource
for plain
connections for the end user.NCLOB
type.PreparedStatement
object.JDBCResultSet
object using the specified
navigator and org.hsqldb.result.ResultMetaData
.
ResultSet
object.Connection.rollback
method.XMLStreamWriter
from SAX events.ResultSet
object.
BLOB
value
designated by this Blob
object.
BLOB
value designated
by this Blob
object.
BLOB
value
designated by this Blob
object.
CLOB
value
designated by this Clob
object.
CLOB
value
designated by this Clob
object.
CLOB
value
designated by this Clob
object.
JDBCResultSet
object for
use with user defined functions that retrun a ResultSet object.
NULL
and non-NULL
values being
NULL
.
NULL
values are sorted at the end regardless of
sort order.
NULL
values are sorted at the start regardless
of sort order.
NULL
values are sorted high.
NULL
values are sorted low.
ResultSet
object,
the result set's own updates are visible.
pattern
begins within the BLOB
value that this Blob
object represents.
BLOB
value
designated by this Blob
object at which
pattern
begins.
pattern
begins within the BLOB
value that
this Blob
object represents.
BLOB
value designated
by this Blob
object at which pattern
begins.
pattern
begins within the BLOB
value that this Blob
object represents.
BLOB
value
designated by this Blob
object at which
pattern
begins.
searchstr
appears in the SQL CLOB
value
represented by this Clob
object.
Clob
object searchstr
appears in this
Clob
object.
searchstr
appears in the SQL CLOB
value
represented by this Clob
object.
Clob
object searchstr
appears in this
Clob
object.
pattern
appears in the CLOB
value
represented by this Clob
object.
Clob
object searchstr
appears in this
Clob
object.
Clob
object searchstr
appears in this
Clob
object.
CallableStatement
object for calling
database stored procedures.
CallableStatement
object that will generate
ResultSet
objects with the given type and concurrency.
CallableStatement
object that will generate
ResultSet
objects with the given type and concurrency.
PreparedStatement
object for sending
parameterized SQL statements to the database.
PreparedStatement
object that will generate
ResultSet
objects with the given type and concurrency.
PreparedStatement
object that will generate
ResultSet
objects with the given type, concurrency,
and holdability.
PreparedStatement
object that has
the capability to retrieve auto-generated keys.
PreparedStatement
object capable
of returning the auto-generated keys designated by the given array.
PreparedStatement
object capable
of returning the auto-generated keys designated by the given array.
ResultSet
object.
RCData
object.
parameterIndex
to the JDBC type
sqlType
.
parameterIndex
to be of JDBC type
sqlType
.
parameterName
to the JDBC type
sqlType
.
parameterName
to be of JDBC type
sqlType
.
Savepoint
(JDBC4 Clarification:) and subsequent Savepoint
objects from the current
transaction.
Connection
object.
Savepoint
object
was set.
java.sql.Array
object.
CLOB
value that this Clob
object represents,
starting at position pos
.
CLOB
value that this Clob
object represents,
starting at position pos
.
CLOB
value that this Clob
object represents,
starting at position pos
.
java.math.BigDecimal
value.
java.math.BigDecimal
value.
BLOB
value that this Blob
object represents.
BLOB
value that this Blob
object represents.
BLOB
value that this Blob
object represents.
InputStream
object.
java.sql.Blob
object.
InputStream
object.
java.sql.Blob
object.
InputStream
object.
InputStream
object.
boolean
value.
boolean
value.
byte
value.
byte
value.
BLOB
value that
this Blob
object represents, starting at position
pos
, and returns the number of bytes written.
byte
array to the
BLOB
value that this Blob
object represents
and returns the number of bytes written.
BLOB
value that
this Blob
object represents, starting at position
pos
, and returns the number of bytes written.
byte
array to the
BLOB
value that this Blob
object represents
and returns the number of bytes written.
BLOB
value that
this Blob
object represents, starting at position
pos
, and returns the number of bytes written.
byte
array to the
BLOB
value that this Blob
object represents
and returns the number of bytes written.
Connection
object's database
in which to work.
Reader
object, which is the given number of characters long.
Reader
object, which is the given number of characters long.
Reader
object.
CLOB
value that this Clob
object
represents, at position pos
.
CLOB
value that this Clob
object
represents, at position pos
.
CLOB
value that this Clob
object
represents, at position pos
.
Reader
object, which is the given number of characters long.
Reader
object, which is the given number of characters long.
Reader
object.
Reader
object.
java.sql.Clob
object.
Reader
object.
java.sql.Clob
object.
Reader
object.
Reader
object.
String
, which
will be used by subsequent Statement
object
execute
methods.
String
, which
will be used by subsequent Statement
object
execute
methods.
java.sql.Date
value
(JDBC4 clarification:)
java.sql.Date
value,
using the given Calendar
object.
java.sql.Date
value
using the default time zone of the virtual machine that is running
the application.
java.sql.Date
value,
using the given Calendar
object.
JDBCBlobFile.free()
.
JDBCClobFile.free()
.
double
value.
double
value.
ResultSet
objects created using this Statement
object.
ResultSet
object will be processed.
ResultSet
objects created using this Statement
object.
ResultSet
objects genrated by this Statement
.
ResultSet
object.
ResultSet
objects genrated by this Statement
.
float
value.
float
value.
ResultSet
objects
created using this Connection
object to the given
holdability.
int
value.
int
value.
DataSource
object to the given java.io.PrintWriter
object.
DataSource
object to the given java.io.PrintWriter
object.
long
value.
long
value.
ResultSet
Sets the limit for the maximum number of bytes that can be returned for
character and binary column values in a ResultSet
object produced by this Statement
object.
ResultSet
Sets the limit for the maximum number of bytes that can be returned for
character and binary column values in a ResultSet
object produced by this Statement
object.
ResultSet
object generated by this Statement
object can contain to the given number.
ResultSet
object generated by this Statement
object can contain to the given number.
Reader
object.
Reader
object.
Reader
object.
Reader
object.
java.sql.NClob
object.
Reader
object.
Reader
object.
java.sql.NClob
object.
Reader
object.
Reader
object.
Connection
or
objects created from the Connection
will wait for the database to reply to any one request.
String
object.
String
object.
NULL
.
NULL
.
NULL
.
NULL
.
Statement
be pooled or not pooled.
Statement
be pooled or not pooled.
Statement
object to execute to the given number of seconds.
Statement
object to execute to the given number of seconds.
REF(<structured-type>)
value.
java.sql.RowId
object.
java.sql.RowId
object.
Savepoint
object that represents it.
Savepoint
object that represents it.
short
value.
short
value.
java.sql.SQLXML
object.
java.sql.SQLXML
object.
String
value.
String
to the CLOB
value that this Clob
object designates at the position
pos
.
len
characters of str
, starting
at character offset
, to the CLOB
value
that this Clob
represents.
String
to the CLOB
value that this Clob
object designates at the position
pos
.
len
characters of str
, starting at
character offset
, to the CLOB
value that
this Clob
represents.
String
to the CLOB
value that this Clob
object designates at the position
pos
.
len
characters of str
, starting
at character offset
, to the CLOB
value
that this Clob
represents.
String
value.
java.sql.Time
value.
java.sql.Time
value,
using the given Calendar
object.
java.sql.Time
value.
java.sql.Time
value,
using the given Calendar
object.
java.sql.Timestamp
value.
java.sql.Timestamp
value,
using the given Calendar
object.
java.sql.Timestamp
value.
java.sql.Timestamp
value,
using the given Calendar
object.
Connection
object to the one given.
TypeMap
object as the type map for
this Connection
object.
java.net.URL
object.
java.net.URL
value.
ALTER TABLE
with add column.
ALTER TABLE
with drop column.
CONVERT
for the conversion of one JDBC type to another.
CONVERT
for conversions between the JDBC types fromType
and toType.
ORDER BY
lists.
GROUP BY
clause.
SELECT
statement in a GROUP BY
clause
provided that all of the columns in the SELECT
statement
are included in the GROUP BY
clause.
SELECT
statement in a
GROUP BY
clause.
LIKE
escape clause.
ResultSet
objects
returned from a CallableStatement
object
simultaneously.
ResultSet
objects from a single call to the
method execute
.
SELECT
statement in an
ORDER BY
clause.
DELETE
statements.
UPDATE
statements.
SELECT FOR UPDATE
statements.
EXISTS
expressions.
IN
expressions.
UNION
.
UNION ALL
.
ARRAY[..., ...]
ARRAY[..., ...]
java.sql.RowId
object.
BLOB
value that this Blob
object represents to be len
bytes in length.
BLOB
value that this Blob
object represents to be len
bytes in length.
BLOB
value that this Blob
object represents to be len
bytes in length.
CLOB
value that this Clob
designates to have a length of len
characters.
CLOB
value that this Clob
designates to have a length of len
characters.
CLOB
value that this Clob
designates to have a length of len
characters.
java.sql.Array
value.
java.sql.Array
value.
java.math.BigDecimal
value.
java.sql.BigDecimal
value.
java.sql.Blob
value.
java.sql.Blob
value.
boolean
value.
boolean
value.
byte
value.
byte
value.
byte
array value.
java.sql.Clob
value.
java.sql.Clob
value.
Reader
object, which is the given number of characters long.
Reader
object, which is the given number of characters long.
Reader
object.
Reader
object.
java.sql.Date
value.
java.sql.Date
value.
double
value.
double
value.
float
value.
float
value.
int
value.
int
value.
long
value.
long
value.
java.sql.NClob
value.
java.sql.NClob
value.
Reader
object, which is the given number of characters long.
Reader
object, which is the given number of characters long.
Reader
The data will be read from the stream
as needed until end-of-stream is reached.
Reader
object.
String
value.
String
value.
null
value.
null
value.
Object
value.
Object
value.
Object
value.
Object
value.
java.sql.Ref
value.
java.sql.Ref
value.
ResultSet
object.
RowId
value.
RowId
value.
ResultSet.rowUpdated
.
short
value.
short
value.
java.sql.SQLXML
value.
java.sql.SQLXML
value.
String
value.
String
value.
java.sql.Time
value.
java.sql.Time
value.
java.sql.Timestamp
value.
java.sql.Timestamp
value.
NULL
.
NULL
.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Welcome to my website which includes blog pages documenting my journey through learning how to code with Dev Academy.
Reflection Blog
Time and Habbits Blog
Emotional Intelligence Blog
Technical Blog Part 1
Technical Blog Part 2
Technical Blog Part 3
Control Blog
JavaScript Scope Blog
Leadership Blog
Meditation Blog
Javascript Blog
Daily Mindfulness Blog
Self Confidence Blog
Problem Solving Blog
JavaScript Language Blog
Motivation Blog
Connecting Blog
Calculate Something Here