which implements the code needed to handle the unique features of the database (H2DatabaseType, MySqlDatabaseType, etc.).
If you want to help develop and test against other SQL databases, a externally available server that the author could connect
to and test against would be appreciated. Please contact the author if your database is not supported or if you want to help.
The following methods are currently used by the system to isolate the database specific behavior in one place.
See the javadocs for the DatabaseType
class for the most up to date information.
isDatabaseUrlThisType
Return true if the database URL corresponds to this database type. Usually the URL is in the form jdbc:ddd:…
where ddd is the driver url part.
loadDriver
Load the driver class associated with this database so it can wire itself into JDBC.
appendColumnArg
Takes a field type and appends the SQL necessary to create the field. It may also generate arguments for the end of the table create statement or commands that must run before or after the table create.
dropColumnArg
Takes a field type and adds all of the commands necessary to drop the column from the database.
appendEscapedEntityName
Add a entity-name (table or column name) word to the SQL wrapped in the proper characters to escape it. This avoids problems with table, column, and sequence-names being reserved words.
appendEscapedWord
Add the word to the string builder wrapped in the proper characters to escape it. This avoids problems with data values being reserved words.
generateIdSequenceName
Return the name of an ID sequence based on the table-name and the field-type of the id. This is required by some database types when we have generated ids.
getCommentLinePrefix
Return the prefix to put at the front of a SQL line to mark it as a comment.
isIdSequenceNeeded
Return true if the database needs a sequence when you insert for generated IDs. Some databases handle generated ids internally.
getFieldConverter
Return the field converter associated with a particular field type. This allows the database instance to convert a field as necessary before it goes to the database.
isVarcharFieldWidthSupported
Return true if the database supports the width parameter on VARCHAR fields.
isLimitSqlSupported
Return true if the database supports the LIMIT sql command.
isLimitAfterSelect
Return true if the LIMIT should be called after SELECT otherwise at the end of the WHERE (the default).
appendLimitValue
Add the necessary SQL to limit the results to a certain number.
isOffsetSqlSupported
Return true if the database supports the OFFSET SQL command in some form.
isOffsetLimitArgument
Return true if the database supports the offset as a comma argument from the limit. This also means that the limit must be specified if the offset is specified.
appendOffsetValue
Append to the string builder the necessary SQL to start the results at a certain row number.
appendSelectNextValFromSequence
Add the SQL necessary to get the next-value from a sequence. This is only necessary if isIdSequenceNeeded returns true.
appendCreateTableSuffix
Append the SQL necessary to properly finish a CREATE TABLE line.
isCreateTableReturnsZero
Returns true if a ’CREATE TABLE’ statement should return 0. False if > 0.
isEntityNamesMustBeUpCase
Returns true if table and field names should be made uppercase. This is an unfortunate "feature" of Derby and Hsqldb. See the Javadocs for the class for more information.
isNestedSavePointsSupported
Returns true if the database supports nested savepoints (transactions).
getPingStatement
Return an statement that doesn’t do anything but which can be used to ping the database by sending it over a database connection.
isBatchUseTransaction
Returns true if batch operations should be done inside of a transaction. Default is false in which case auto-commit disabling will be done.
isTruncateSupported
Returns true if the table truncate operation is supported.
isCreateIfNotExistsSupported
Returns true if the table creation IF NOT EXISTS
syntax is supported.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The DAO classes provide the following methods that you can use to store your objects to your database.
This list may be out of date. See the Dao
interface class for the latest methods.
queryForId(ID id)
Looks up the id in the database and retrieves an object associated with it.
queryForFirst(PreparedQuery<T> preparedQuery)
Query for and return the first item in the object table which matches a prepared statement. This can be used to return the object that matches a single unique column. You should use queryForId if you want to query for the id column.
queryForAll()
Query for all of the items in the object table and return a list of them. For medium sized or large tables,
this may load a lot of objects into memory so you should consider using the iterator
method instead.
queryForEq(String fieldName, Object value)
Query for the items in the object table that match a simple where with a single field = value
type of WHERE clause. This
is a convenience method for calling queryBuilder().where().eq(fieldName, value).query()
.
queryForMatching(T matchObj)
Query for the rows in the database that match the object passed in as an argument. Any fields in the matching object that
are not the default value (null, false, 0, 0.0, etc.) are used as the matching parameters with AND
. If you are worried
about SQL quote escaping, you should use queryForMatchingArgs
.
queryForMatchingArgs(T matchObj)
Same as queryForMatching
but this uses SQL ? arguments. This is slightly more expensive but you don’t have to worry about
SQL quote escaping.
queryForFieldValues(Map<String, Object> fieldValues)
Query for the rows in the database that matches all of the field to value entries from the map passed in.
queryForFieldValuesArgs(Map<String, Object> fieldValues)
Same as queryForFieldValues
but this uses SQL ? arguments. This is slightly more expensive but you don’t have to worry
about SQL quote escaping.
queryForSameId(T data)
Query for a data item in the table that has the same ID as the data parameter.
queryBuilder()
Create and return a new QueryBuilder
object which allows you to build a custom query. See section Query Builder Basics.
updateBuilder()
Create and return a new UpdateBuilder
object which allows you to build a custom update statement. See UpdateBuilder.
deleteBuilder()
Create and return a new DeleteBuilder
object which allows you to build a custom delete statement. See DeleteBuilder.
query(PreparedQuery<T> preparedQuery)
Query for the items in the object table which match a prepared statement. See section Custom Statement Builder. This returns a
list of matching objects. For medium sized or large tables, this may load a lot of objects into memory so you
should consider using the iterator
method instead.
create(T data)
Create a new entry in the database from an object. Should return 1 indicating 1 row was inserted.
createIfNotExists(T data)
This is a convenience method to creating a data item but only if the ID does not already exist in the table. This extracts the id from the data parameter, does a query for on it, returning the data if it exists. If it does not exist then create is called with the data parameter.
createOrUpdate(T data)
This is a convenience method for creating an item in the database if it does not exist. The id is extracted from
the data argument and a query-by-id is made on the database. If a row in the database with the same id exists
then all of the columns in the database will be updated from the fields in the data parameter. If the id is null
(or 0 or some other default value) or doesn’t exist in the database then the object will be created in the
database. This also means that your data item must have an id field defined.
update(T data)
Save the fields from an object to the database. If you have made changes to an object, this is how you persist
those changes to the database. You cannot use this method to update the id field – see updateId()
. This
should return 1 since 1 row was updated.
updateId(T data, ID newId)
Update an object in the database to change its id to a new id. The data must have its current id set and the new-id is passed in as an argument. After the id has been updated in the database, the id field of the data object will also be changed. This should return 1 since 1 row was updated.
update(PreparedUpdate<T> preparedUpdate)
Update objects that match a custom update statement.
refresh(T data, ID newId)
Does a query for the object’s id and copies in each of the field values from the database to refresh the data parameter. Any local object changes to persisted fields will be overwritten. If the database has been updated this brings your local object up-to-date. This should return 1 since 1 row was retrieved.
delete(T data)
Delete an object from the database. This should return 1 since 1 row was removed.
deleteById(ID id)
Delete an object from the database if you have its id. This should return 1 since 1 row was removed.
delete(Collection<T> datas)
Delete a collection of objects from the database using an IN SQL clause. This returns the number of rows that were deleted.
deleteIds(Collection<ID> ids)
Delete the objects that match the collection of ids from the database using an IN SQL clause. This returns the number of rows that were deleted.
delete(PreparedDelete<T> preparedDelete)
Delete objects that match a custom delete statement.
iterator()
This method satisfies the Iterable
Java interface for the class and allows you to iterate through the objects
in the table using SQL. This method allows you to do something like:
for (Account account : accountDao) { … } |
WARNING: See the Dao
class for warnings about using this method.
iterator(PreparedQuery<T> preparedQuery)
Same is the iterator
method but with a prepared statement parameter. See section Custom Statement Builder.
getWrappedIterable()
This returns a one time use iterable class that can be closed afterwards. The DAO itself is
CloseableWrappedIterable
but multiple threads can each call this to get their own closeable iterable.
This allows you to do something like:
CloseableWrappedIterable<Account> wrappedIterable = accountDao.getWrappedIterable(); try { for (Account account : wrappedIterable) { … } } finally { wrappedIterable.close(); } |
getWrappedIterable(PreparedQuery<T> preparedQuery)
Same as getWrappedIterable()
but with a prepared query parameter.
closeLastIterator()
This closes the last iterator returned by the iterator()
method.
NOTE: This is not reentrant. If multiple threads are getting iterators from this DAO then you should use
getWrappedIterable()
method.
queryRaw(String query, String... arguments)
Query for all of the items in the object table that match the SQL select query argument. This method allows you
to do special queries that aren’t supported otherwise. For medium sized or large tables, this may load a lot of
objects into memory so you should consider using the iterator()
method on the GenericRawResults
instead of the getResults
method. See section Issuing Raw Queries.
queryRaw(String query, RawRowMapper<UO> mapper, String... arguments)
Same as the above queryRaw
method but with the addition of a row mapper. Instead of each row being returned
as an array of strings, this will map the row using the mapper object passed in. See section Issuing Raw Queries.
queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper, String... arguments)
Similar to the above queryRaw
but uses the column-types array to present an array of object results to the mapper
instead of strings. The arguments are optional but can be set with strings to expand ?
type of SQL. See section Issuing Raw Queries.
queryRaw(String query, DataType[] columnTypes)
Same as the above queryRaw
method but with the addition of a an array of column data types. Instead of each
row being returned as an array of strings, they are returned as an array of objects. See section Issuing Raw Queries.
queryRawValue(String query, String... arguments)
Perform a raw query that returns a single value (usually an aggregate function like MAX
or COUNT
). If the query
does not return a single long value then it will throw a SQLException.
executeRaw(String statement)
Run a raw execute SQL statement against the database. See section Issuing Raw Execute Statements.
updateRaw(String statement)
Run a raw update SQL statement (INSERT
, DELETE
, or UPDATE
against the database.
See section Issuing Raw Update Statements.
callBatchTasks(Callable callable)
Call the call-able that will perform a number of batch tasks. This is for performance when you want to run a number of database operations at once – maybe loading data from a file. This will turn off what databases call "auto-commit" mode, run the call-able and then re-enable "auto-commit". If auto-commit is not supported then it will try to use a database transaction to speed up the tasks.
NOTE: If neither auto-commit nor transactions are supported by the database type then this method may not give any performance improvement.
accountDao.callBatchTasks(new Callable<Void>() { public Void call() throws SQLException { // insert a number of accounts at once for (Account account : accountsToInsert) { // update our account object accountDao.create(account); } return null; } }); |
countOf()
Returns the value returned from a SELECT COUNT(*)
query which is the number of rows in the table. Depending on the
database and the size of the table, this could be expensive.
countOf(PreparedQuery<T> preparedQuery)
Returns the number of rows in the table associated with the prepared query passed in. Depending on the size of the table and the database type, this may be expensive and take a while.
assignEmptyForeignCollection(T parent, String fieldName)
Assigns an empty collection to the appropriate collection field that has the field-name. This allows you to add things to the collection from the start. This allows you to do something like:
accoundDao.assignEmptyForeignCollection(account, "orders"); // this would add it the collection and the internal DAO account.orders.add(order1); |
setObjectCache(boolean enabled);
Call this with true to enable an object cache for the DAO. Set to false to disable any caching. See section Object Caches.
setObjectCache(ObjectCache objectCache);
Same as setObjectCache(boolean)
except you specify the actual cache instance to use for the DAO. This allows
you to inject your own cache classes. Call it with null to disable the cache. See section Object Caches.
clearObjectCache();
Flush the object cache if it has been enabled. This will remove an objects that are in the cache to reclaim memory. Any future queries will re-request them from the database.
mapSelectStarRow(DatabaseResults results)
Return the latest row from the database results from a query to select *
(star). This allows you to remap the
results. It is particularly useful if you are repositioning a database cursor externally.
getSelectStarRowMapper()
Return a row mapper that is suitable for mapping results from a query to select *
(star).
idExists(ID id)
Returns true if an object exists that matches this ID otherwise false.
startThreadConnection()
WARNING: This method is for advanced users only. It is only to support the setAutoCommit(conn, boolean)
and other methods below. Chances are you should be using the TransactionManager
class’ callInTransaction(Callable)
method instead f this method unless you know what you are doing.
This allocates a connection for this specific thread that will be used in all other DAO operations. The thread
must call endThreadConnection(conn)
once it is done with the connection. It is highly recommended that a
try / finally
pattern be used here to ensure you do not leak connections.
This is really only useful if you are using a pooled connection source and want to do certain operations on the same pool. Android users, for example have a single connection to the database so this is effectively a no-op.
endThreadConnection(DatabaseConnection connection)
This method is used to free the connection returned by the startThreadConnection()
above.
setAutoCommit(DatabaseConnection connection, boolean autoCommit)
Set auto-commit mode to be true or false on the connection returned by the startThreadConnection()
. This
may not be supported by all database types.
isAutoCommit(DatabaseConnection connection)
Return true if the database connection returned by the startThreadConnection()
is in auto-commit mode
otherwise false. This may not be supported by all database types.
commit(DatabaseConnection connection)
If you have previously called setAutoCommit(conn, false)
then this will commit all changes to the database
made from that point up to now on the connection returned by the startThreadConnection()
. The changes
will be written to the database and discarded. The connection will continue to stay in the current auto-commit
mode.
WARNING: Chances are you should be using the TransactionManager
class’ callInTransaction(Callable)
method instead unless you know what you are doing.
rollBack(DatabaseConnection connection)
If you have previously called setAutoCommit(conn, false)
then this will roll-back and flush all changes to the
database made from that point up to now on the connection returned by the startThreadConnection()
. None
of those changes will be written to the database and are discarded. The connection will continue to stay in the
current auto-commit mode.
WARNING: Chances are you should be using the TransactionManager
class’ callInTransaction(Callable)
method instead unless you know what you are doing.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
ORMLite uses a log system which can plug into Apache commons logging, Log4j, Android Log, or its own internal
log implementations. The logger code first looks for the android.util.Log
and if found will use the Android internal
logger. Next it looks for org.apache.commons.logging.LogFactory
class in the class-path – if found it will use Apache
commons logging. If that class is not found it then looks for org.apache.log4j.Logger
and if found will use Log4j.
If none of these classes are available it will use an internal logger – see LocalLog
. The logger code also provides
simple {} argument expansion like slf4j
which means that you can save on toString()
calls and
StringBuilder
operations if the log level is not high enough. This allows us to do something like the following:
private static Logger logger = LoggerFactory.getLogger(QueryBuilder.class); … logger.debug("built statement {}", statement); |
If you are using log4j (through Apache commons logging or directly), you can use something
like the following as your log4j.properties
file to see details about the SQL calls.
log4j.rootLogger=INFO, stdout log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout # print the date in ISO 8601 format log4j.appender.stdout.layout.ConversionPattern=%d{ISO8601} [%p] %c{1} %m%n # be more verbose with our code log4j.logger.com.j256.ormlite=DEBUG # to enable logging of arguments to all of the SQL calls # uncomment the following lines #log4j.logger.com.j256.ormlite.stmt.mapped.BaseMappedStatement=TRACE #log4j.logger.com.j256.ormlite.stmt.mapped.MappedCreate=TRACE #log4j.logger.com.j256.ormlite.stmt.StatementExecutor=TRACE |
Notice that you can uncomment the last lines in the above log4j.properties file to log the arguments to the various SQL calls. This may expose passwords or other sensitive information in the database so probably should only be used during debugging and should not be the default.
If you are using the LocalLog
logger (which is helpful for testing at least) then you can configure it using
a ormliteLocalLog.properties
file. The file configures the log output of the ORMLite LocalLog class.
Lines in the file have the format class-regex-pattern = Level
. For example:
com\.j256\.ormlite.* = DEBUG com\.j256\.ormlite\.stmt\.mapped\.BaseMappedStatement = TRACE com\.j256\.ormlite\.stmt\.mapped\.MappedCreate = TRACE com\.j256\.ormlite\.stmt\.StatementExecutor = TRACE |
NOTE: You should escape any period characters with a single backslash unless they are part of a regex match.
For all of the logging implementations, you can use the Logger.setGlobalLogLevel(...)
method to filter all log
messages. The argument you pass in filters out any messages to less important levels. You should call that method
in the main(...)
method or as early in your application as possible.
// filter out TRACE messages only Logger.setGlobalLogLevel(Level.DEBUG); // only allow error or fatal messages Logger.setGlobalLogLevel(Level.ERROR); // turn off all log messages Logger.setGlobalLogLevel(Level.OFF); |
You can also implement your own logging implementation by using the LoggerFactory.setLogFactory(...)
method.
The the factory needs to implement a Log createLog(String)
method and the Log
class only has a couple
methods to test the log level and log messages with optional throwables.
To force the logging backend to use a particular logging system, you should call the following method as early as possible in your application.
LoggerFactory.setLogBackendFactory(LogBackendType.SLF4J); |
You can use the NullLogFactory
as another way to disable all log messages by sending them to NullLog
which ignores all log calls.
To disable all logs, you can use the following code also called as early as possible which ignores all log messages.
LoggerFactory.setLogBackendFactory(LogBackendType.NULL);. |
For logging with Android, See section Android Logging.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
ORMLite does not have any direct dependencies. It has logging classes that depend on Apache commons-logging and Log4j but these classes will not be referenced unless they exist in the class-path.
If you want to get the ORMLite Junit tests to run, there are test dependencies on the following packages:
javax.persistence
For testing the compatibility annotations @Column
and the like.
org.junit
We use Junit for our unit tasks.
org.easymock.easymock
We use, and are in love with, EasyMock. It allows us to mock out dependencies so we can concentrate on testing a particular class instead of the whole package.
com.h2database
As a test database implementation, H2 is very fast and simple to use. However, we recommend MySQL or Postgres for multi-threaded, high-performance, production databases.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Database transactions allow you to make a number of changes to the database and then if any of them fail, none of the changes are actually written. For example, let’s say you are recording an order into your order entry system which requires you to insert a row into the Order table and also to update the Account table with the order number. If the Order was inserted but then a disk error stopped the Account from being updated, the Order data would be left dangling. If you used a transaction then both changes would be saved to the database only when the transaction was closed. Most (not all) databases support transactions which are designed specifically with these sorts of scenarios in mind.
ORMLite has basic support for transactions through the use of the TransactionManager
class which wraps
databases operations in a transaction. If those operations throw an exception, then the transaction is "rolled-back"
and none of the operations are persisted to the database. Once the operations are finished, if no exception is thrown,
then the transaction is "committed" and the changes are written to the database.
// we need the final to see it within the Callable final Order order = new Order(); TransactionManager.callInTransaction(connectionSource, new Callable<Void>() { public Void call() throws Exception { // insert our order orderDao.create(order); // now add the order to the account account.setOrder(order); // update our account object accountDao.update(account); // you could pass back an object here return null; } }); |
If for some reason, the accountDao.update()
fails in the above example, the order insert will not be committed to
the database. Transactions allow you to make multiple operations while still ensuring data integrity. Notice that you
can return an object from the callable so you could pass back the number of rows affected or other information.
NOTE: Performing database operations within a transaction also has the side effect of better performance since
a number of changes are written at once in a batch. The Dao.callBatchTasks()
method should always be used if
you are looking for performance of a large number of operations. See callBatchTasks.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
ORMLite supports the ability to enable a basic object cache for a DAO. The object cache keeps an internal collection of objects that have been created or queried and will return a reference to the same object if it is handled in the future.
For example:
Dao<Account, String> accountDao = DaoManager.createDao(connectionSource, Account.class); // enable the default object cache for this dao accountDao.setObjectCache(true); Account account = new Account("Jim Coakley"); accountDao.create(account); // this will create the account object and add it to cache Account result = dao.queryForId("Jim Coakley"); // this result will be the same object as account above assertSame(account, result); |
NOTE: For an object cache to work, the class being stored must have an ID field. If you try to enable the object cache for a class without an ID field, an exception will be thrown. The following operations are supported by the object cache:
queryRaw(...)
methods.
By default the cache that is used internally by ORMLite if you enable the cache with true
will be a "weak-reference" cache. This
means that if no other code has a strong reference to the object, it will be removed from the cache during the next garbage collection
cycle. ORMLite also has a "soft-reference" cache which will use more memory to hold objects if available and supported by your OS. You
can enable it using:
Dao<Account, String> accountDao = DaoManager.createDao(connectionSource, Account.class); // enable a soft-reference cache accountDao.setObjectCache( ReferenceObjectCache.makeSoftCache()); |
The reference caches store a small object that refers to the cached object. These small objects only get cleaned up when the object is
accessed. You should consider calling the cleanNullReferencesAll()
method on your cache to remove these objects and free up
their associated memory on occasion.
There is also a Least Recently Used (LRU) cache that will store a certain number of objects based on a capacity value. Each class gets
the same capacity value so if the same cache is used in 5 different daos, then 500 objects will be held in the LruObjectCache
if
the capacity is 100.
Dao<Account, String> accountDao = DaoManager.createDao(connectionSource, Account.class); // enable least-recently-used cache with max 100 items per class accountDao.setObjectCache(new LruObjectCache(100)); |
You can also implement your own cache class that implements the ObjectCache
interface.
All of the caches can be cleared if you want to free up memory and you can also disable the cache from the DAO if necessary.
// clear all Account items from the cache accountDao.clearObjectCache(); … // disable the cache accountDao.setObjectCache(false); |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
To use ORMLite in your project if you are using maven, then you should add the following configuration stanza
to your pom.xml
file. As mentioned below, you will also need to add some database driver as well to your
dependency list. In this example we are using MySQL but any of the supported JDBC database drivers will do.
<project> … <dependencies> <dependency> <groupId>com.j256.ormlite</groupId> <artifactId>ormlite-jdbc</artifactId> <version>6.1</version> </dependency> <!-- You will need to add some sort of database driver too. In this example we've used MySQL. --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.10</version> </dependency> </dependencies> </project> |
NOTE: I do not have any details about how to configure Android projects with maven. If you are doing so
then just replace the ormlite-jdbc
artifact name with ormlite-android
.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Every so often you need to efficiently do a number of database updates at one time – bulk database inserts is a common
pattern. ORMLite supports a callBatchTasks
method on the Dao
class which supports this behavior in most
database types. For example:
final List<Account> accountsToInsert = new ArrayList<Account>(); … accountDao.callBatchTasks(new Callable<Void>() { public Void call() throws Exception { for (Account account : accountsToInsert) { accountDao.create(account); } } }); |
Databases by default commit changes after every SQL operation. This method disables this "auto-commit" bahavior so a
number of changes can be made faster and then committed all at once. More specifically, the method turns "auto-commit",
calls the Callable.call()
method passed in as an argument, calls SQL commit
to persist the changes when the
call returns, and finally re-enabled auto-commit. Some databases do not support auto-commit so a transaction may be used
to accomplish the same behavior.
NOTE: If neither auto-commit nor transactions are supported by the database type then callBatchTasks
method
may do nothing.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
ORMLite has internal definitions for storing the basic primitive and other common data types. See section Persisted Data Types.
Sometimes, however, you either want to store a new data type in your database or you want to change the way ORMLite
stores values to the database for common types – this often happens when you are trying to work with an existing schema.
You can change how types are stored in the database by defining a class which implements the DataPersister
interface.
For example, you might have a Date
field in an existing database that was not nullable but instead stored the date
0000-00-00
when there was no date. You want ORMLite to return null if the 0 date was retrieved from the database.
To implement a custom data persister to handle the Date
type in this manner would probably override the
com.j256.ormlite.field.types.DateType
class and tweak the result-to-sql-argument method as follows:
@Override public Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos) throws SQLException { Timestamp timestamp = results.getTimestamp(columnPos); if (TODO: somehow test fo 0000-00-00 here) return null; else return timestamp; } |
The data persister example has a MyDatePersister
class which does just that. See data persister example.
To use your persister class on a particular field in your objects, you would do something like this:
@DatabaseField(persisterClass = MyDatePersister.class) Date birthDate; |
ORMLite also allows you to define data persisters for atypical or custom data types that are not handled at all by
the internal classes. When defining a data persister class from scratch, you could extend one of the other data type
persisters or the BaseDataType
class. You will need to define the following methods.
parseDefaultString
– Converts a default string into a SQL argument suitable to be loaded into the database.
resultToSqlArg
– Uses the DatabaseResults
object to get the right SQL argument type out of the
results.
sqlArgToJava
– Converts the SQL argument to the associated Java class.
Look at the other data
types in com.j256.ormlite.field.types
for other examples. When you have defined your persister class, you can use
it with the persisterClass
construct above or you can register it with the
DataPersisterManager.registerPersisters(...)
method. This will then automatically call your persister whenever a
field with the associated class is configured.
DataPersisterManager.registerDataPersisters( MyTypePersister.getSingleton()); |
You probably would not want to register the MyDatePersister
above because you would not want to change the
persistence behavior for all Date
types.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
We strive to maintain backwards compatibility and to provide deprecated versions of old classes and methods. However, sometimes when a new version is released, changes are made that require programmers to change their code and rarely the on-disk database formats.
| 6.1 Notes About Version 6.1 | Notes about version 6.1 | |
| 6.2 Notes About Version 6.0 | Notes about version 6.0 | |
| 6.3 Notes About Version 5.7 | Notes about version 5.7 | |
| 6.4 Notes About Version 5.2 | Notes about version 5.2 | |
| 6.5 Notes About Version 5.1 | Notes about version 5.1 | |
| 6.6 Notes About Version 5.0 | Notes about version 5.0 | |
| 6.7 Notes About Version 4.49 | Notes about version 4.49 | |
| 6.8 Upgrade to Version 4.45 | Upgrade to version 4.45 | |
| 6.9 Problems With Version 4.43 | Problems with version 4.43 | |
| 6.10 Upgrade to Version 4.37 | Upgrade to version 4.37 | |
| 6.11 Upgrade to Version 4.30 | Upgrade to version 4.30 | |
| 6.12 Upgrade to Version 4.20 | Upgrade to version 4.20 | |
| 6.13 Upgrade to Version 4.14 | Upgrade to version 4.14 | |
| 6.14 Upgrade to Version 4.10 | Upgrade to version 4.10 | |
| 6.15 Upgrade to Version 4.0 | Upgrade to version 4.0 | |
| 6.16 Upgrade to Version 3.2 | Upgrade to version 3.2 | |
| 6.17 Upgrade to Version 2.4 | Upgrade to version 2.4 |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Because of the fervor around the #Log4Shell bug, I’ve bumped the log4j2 release to 2.17.0. For the record ORMLite uses the SimpleLogging shim between it and the logging backends that would only access log4j2 if someone else provided the dependency. Also log4j2 2.17.0 depends on Java 8 while we are still on Java 7 so the tests have been ignored.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
ORMLite has [finally] moved to a shaded unified jar. You no longer need to add ormlite-core
to your classpath when you use ormlite-jdbc
or ormlite-android
.
ORMLite now requires Java 7 and no longer supports Java 6. This allows us to change to using the
AutoCloseable
interface added in Java 7 which means that a number of the different close
methods now throw Exception
instead of IOException
to match AutoCloseable.close()
.
Since we are moving to 6.0, we’ve removed some of the @Deprecated
methods that had been around
for a while.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Added some provisional Stream
support to lazy foreign collections to help with the proper closing
of the underlying iterator and marking of it as unsized. We were able to support this while still keeping
Java 6 compilation level.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In version 5.2, we fixed issues with the boolean SQL types. The boolean number type now correctly uses the
BOOLEAN
SQL type instead of BYTE
. The boolean character type now correctly uses the CHAR
SQL
type instead of STRING
. Although we don’t anticipate any issues with this, the developers thought it prudent
to mention it in case it causes compatibility issues.
We also did refactoring in the ormlite-jdbc
jar by renaming a number of types so it could be fulling Java9
compliant. Before there were overlapping packages. Now all code in the ormlite-jdbc
is under the
com.j256.ormlite.jdbc
package. You may need to edit your imports if you were refering to any of these
classes.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In version 5.0, we moved to using English for the field and method name capitalization because of problems with how certain languages capitalize certain characters. Some of the capitalization points were missed however and this version fixes a couple of additional spots where field and method capitalization was still using the default locale.
If you want ORMLite to use the old way to keep compatibility, you should generate your connection source with a custom database type that uses your default locale by overriding the following methods:
upCaseEntityName(String)
upCaseString(String, boolean)
downCaseString(String, boolean)
These methods should just return string.toUpper()
or string.toLower()
which will use your default
locale. You can also specify a specific locale if necessary.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A number of things have changed and it’s been a long time since the last published ORMLite release, so a .0 number on the release seemed to be warranted. See the following details.
Locale.ENGLISH
. This means that your schema may need to change. To go back
to the old behavior, you should override the appropriate DatabaseType
and override the
upCaseEntityName(String)
method.
java.io.Closeable
interface in a number of places for Java 7 support. This means
that you may not get warnings about unclosed iterators and other things. Watch for and pay attention to them. They are
important. Java 7 is not required.
ConnectionSource
interface so now the
table name is specified which allows the ConnectionSource
to make decisions about which database to connect to
depending on the table.
java.sql.Timestamp
and java.sql.Date
as strings
in the database. If you were using this types before you may have to add a persisterClass = TimeStampType.class
or SqlDateType.class
.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The 4.49 release took a long time to put out unfortunately so it included a lot of changes, a couple of which need to be specifically enumerated. For more details, please check the change-log.
dao.callBatchTasks(...)
calls from multiple threads when dealing with a single database connection. ORMLite
now makes an attempt to detect a single-connection connection-source and will enforce locking so that only one batch
task can be running at a time.
CloseableIterator
and other classes extend java.io.Closeable
. If
you are extending any of these classes then you may have to tweak your code.
maxForeignAutoRefreshLevel
configuration setting which was particularly impacting
Android users.
Again, please check the change-log for the entire list.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
To fix the date-string format bug introduced in version 4.43, I’ve decided to revert back to the date-string of
yyyy-MM-dd HH:mm:ss.SSSSSS
from the one introduced in 4.43 which was yyyy-MM-dd HH:mm:ss.SSS
. This means
that for folks doing date comparisons or using the version = true
feature, if you have created data under 4.43
you will have to add the following to your date fields to make it work.
@DatabaseField(version = true, format="yyyy-MM-dd HH:mm:ss.SSS", dataType=DataType.DATE_STRING) private Date date; |
If you have data that was created both in 4.42 or before and 4.43 or 4.44 then you will have to convert some of
the data. Something like the following UPDATE
statement should work:
UPDATE your-table SET your-date-field = CONCAT(SUBSTRING(your-date-field, 1, 20), "000", SUBSTRING(your-date-field, 20, 3)) WHERE LENGTH(your-date-field) = 23; |
My sincere apologies for this mess up.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In the process of looking into adding the timezone to the date-string, I made a change to the date-string format from
yyyy-MM-dd HH:mm:ss.SSSSSS
to yyyy-MM-dd HH:mm:ss.SSS
– changing the milliseconds output from 6 digits to 3.
This relatively small change broke the equality checking for date-strings which meant that Where.eq(...)
and
version = true
field settings ceased to work correctly. The version processing code uses equality to verify that
the object date is the same with the database and the new string value ...###
is not equal to the old database
format of ...######
.
We have fixed this problem in 4.45 which reverts the string format. If you want to fix it permanently, you can use the
format
specifier on your date-string fields:
@DatabaseField(version = true, format="yyyy-MM-dd HH:mm:ss.SSSSSS", dataType=DataType.DATE_STRING) private Date date; |
My apologies for this problem.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
For Android users, in 4.37 we fixed a problem with the looking up of column names with imbedded periods in them by implementing
our own lookup and not using the Android API. This had the unintended consequence of making the field name lookups be case
sensitive. If you used ORMLite to generate your tables or if you used the @DatabaseField
columnName
to match the case then you would not be affected by this issue. But if you were working with an existing database with
field names that did not match the case of the Java fields, then as of 4.37 you would be seeing the following exception.
java.sql.SQLException: Unknown field 'accountName' from the Android sqlite cursor, not in:[accountname, ...]" |
Since other parts of the system are also case sensitive, we made the decision to not fix this problem but to encourage
our users to properly use the @DatabaseField
columnName
if the case of your database does not match your
Java fields. See columnName.
For example, before 4.37 your Android SQLite database might have the column accountname
although your Java field might
actually be accountName
. As of 4.37, when you look up your Java fields you will have to add a columnName
value
like the following:
@DatabaseField(columnName = "accountname") private String accountName; |
We made the decision to force this change because there are other parts of ORMLite that are already case sensitive.
For example, if you had mismatched case in your field names then using the dao.queryForMatching(obj)
method would
not work without the case matching the database. If you were building a custom query, you would have to say
queryBuilder.where().eq("columnname", value)
and could not use columnName
.
Sorry for not recognizing this incompatibility earlier.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
For Android users, in 4.30 we added some reflection hacks to make the processing of the @DatabaseField
annotations
a lot faster. For this reason the following changes must be made:
DatabaseTableConfig
instead. This means that if you have defined custom Dao classes, you will need to add
a new constructor:
public class AccountDaoImpl extends BaseDaoImpl<Account, String> implements AccountDao { public AccountDaoImpl(ConnectionSource connectionSource) throws SQLException { super(connectionSource, Account.class); } // NOTE: this constructor is needed under Android in 4.30 public AccountDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<Account> tableConfig) throws SQLException { super(connectionSource, tableConfig); } } |
@DatabaseField
annotation we have deprecated the
@DatabaseFieldSimple
and other annotations that were added in version 4.26. Sorry for the reversal on this but
they were also causing confusion.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In 4.20 we made a couple of changes that bear some note.
strings.xml
resource file is still supported although it is not necessary if you are using
OrmLiteBaseActivity
or the other base classes. If you are extending those classes, ORMLite will detect the helper
class automagically. The SqliteOpenHelperFactory
mechanism, although still supported, has been deprecated.
See database open helper wiring.
uniqueCombo
setting for uniqueness across field combinations. We also changed the SQL that was generated
if you are using the unique
setting. The old SQL was correct but the new versions are more compatible with the SQL standard
and the various database types. See unique constraints.
TableUtil
methods. Thanks much to various
folks on the user list who significantly helped with this process.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In 4.14 we added a DatabaseType.BYTE_ARRAY
which stores byte[]
directly. See BYTE_ARRAY. In the past, this array
would have been stored as a serialized array of bytes. To not break backwards compatibility with the database, fields with the
byte[]
type must now specify either the BYTE_ARRAY
or SERIALIZABLE
types using the dataType
field
on @DatabaseField
– it will not be chosen automatically. See DatabaseField dataType. If we did not do this then
previously stored data would be read from the database improperly.
In addition, serialized types must also now specify their dataType
value. You should use DataType.SERIALIZABLE
to
continue to store serialized objects in the database. This will allow us to add direct support for other serialized types in the
future without breaking backwards compatibility.
If you already have Serializable data (byte[] or other objects) stored in a database then you will need to add something like the following to your fields:
@DatabaseField(dataType = DataType.SERIALIZABLE) Serializable field; |
For newly stored byte[] fields, you could use the BYTE_ARRAY type to store the bytes directly. But any existing data will not be converted automatically.
@DatabaseField(dataType = DataType.BYTE_ARRAY) byte[] field; |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
4.10 was a reasonably large release containing some feature upgrades and some bug fixes. No data formats were changed, however the following API code was altered:
RawResults
class which is now deprecated and replaced it with the
GenericRawResults
class. See the GenericRawResults
for more information. See section Issuing Raw Queries.
Dao
methods queryForAllRaw()
and iteratorRaw()
are now deprecated. They are replaced with
queryRaw(...)
methods. See the Dao
class javadocs for more information.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
No data formats were changed, however the following API code was altered. Removed any outside usage of the DatabaseType
since
the ConnectionSource
now provides it. Also added features to be able to prepare update and delete statements. To provide
type safety, we’ve moved back to using QueryBuilder
so we can have UpdateBuilder
and DeleteBuilder
. And instead
of a PreparedStmt
there is PreparedQuery
, PreparedUpdate
, and PreparedDelete
. Here are the details:
DatabaseType
.
All you need to set on the DAOs is the ConnectionSource
which provides the database type
internally. To create and drop the tables, also, you only need the ConnectionSource
.
BaseDaoImpl
now self-initializes if it is constructed with a
ConnectionSource
. This validates the class configurations meaning that it now throws a
SQLException
.
JdbcConnectionSource
or DataSourceConnectionSource
also now
throws a SQLException
since they also now self-initialize if they are constructed with the URL.
This creates the internal database type and loads the driver class for it.
createJdbcConnectionSource
method in the DatabaseTypeUtils
and
turned the loadDriver
method into a no-op. You now just instantiate the JdbcConnectionSource
directly and there is no need for referencing the DatabaseTypeUtils
anymore.
Dao.statementBuilder()
method changed (back) to Dao.queryBuilder()
.
Dao.queryBuilder()
returns a QueryBuilder
instead of a StatementBuilder
.
distinct()
, limit()
and offset()
on the QueryBuilder
.
Unfortunately, there are no deprecated methods for them on the StatementBuilder
.
selectColumns()
on the QueryBuilder
instead of columns()
since now we have columns also in the UpdateBuilder
. Unfortunately, there are no deprecated
methods for them on the StatementBuilder
.
QueryBuilder.prepare()
instead of StatementBuilder.prepareStatement()
.
It returns a PreparedQuery
instead of a PreparedStmt
. You pass a PreparedQuery
into the Dao.query()
and Dao.iterator()
methods instead of a PreparedStmt
.
DatabaseTypeFactory
class since it was no longer needed for Spring
configurations.
BaseJdbcDao
since it had been deprecated in 3.X.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The 3.2 release involved a very large code reorganization and migration. There were no on-disk changes unless you somehow
managed to get ORMLite working previously on Android. The project was basically split into 3 pieces: core functionality, JDBC
database handlers, and the new Android handler. With significant help from Kevin G, we abstracted all of the database calls into
3 interfaces: ConnectionSource
(like a DataSource
), DatabaseConnection
(like a Connection
) and
DatabaseResults
(like a ResultSet
). Once we had the interfaces in place, we wrote delegation classes for JDBC and
Android handlers. This means that as of 3.X we release 3 packages: ormlite-core (for developers), ormlite-jdbc (for people
connecting to JDBC databases), and ormlite-android (for Android users). Both the JDBC and Android packages include all of the
core code as well.
Along the way a number of specific changes were made to the methods and classes:
BaseJdbcDao
to be BaseDaoImpl
in the core package. You will
need to adjust any DAOs that you have.
QueryBuilder
object to be StatementBuilder
. NOTE: this was reverted later.
Dao.queryBuilder()
method to be statementBuilder()
. NOTE: this
was reverted later.
PreparedQuery
object to be PreparedStmt
.
DataSource
is that you no longer set it on the
DAO directly. You need to wrap your DataSource
in a DataSourceConnectionSource
wrapper class which gets
set on the DAO instead.
Again, there were no on-disk changes unless you somehow managed to get ORMLite working previously on Android. Since we were using JDBC before to do the data marshaling and now are doing it by hand, some of the data representations may have changed. Sorry for the lack of detail here.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A bug was fixed in 2.4 with how we were handling Derby and Hsqldb. Both of these databases seem to be capitalizing table and field names in certain situations which meant that customized queries of ORMLite generated tables were affected. In version 2.4, all tables and field names are capitalized in the SQL generated for Derby and Hsqldb databases. This means that if you have data in these databases from a pre 2.4 version, the 2.4 version will not be able to find the tables and fields without renaming to be uppercase.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Here is some example code to help you get going with ORMLite. I often find that code is the best documentation of how to get something working. Please feel free to suggest additional example packages for inclusion here. Source code submissions are welcome as long as you don’t get piqued if we don’t chose your’s.
| 7.1 JDBC Examples | Example code using JDBC calls. | |
| 7.2 Android Examples | Example code for the Android OS. |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
All of the JDBC examples below depend on the H2 database which is a native Java SQL implementation. You can download the latest jar from the website.
This is a simple application which performs database operations on a single class/table. See the source code.
This example shows how to use foreign objects. See section Foreign Object Fields. See the source code.
This example shows how to use foreign collections. See section Foreign Collections. See the source code.
This example shows how you can configure a class in ORMLite using Java code instead of annotations. See section Class Configuration. See the source code.
This example is a bit more complicated with multiple tables and is designed for folks trying to model a many-to-many relationship. It has a join-table, foreign fields, and also utilizes inner queries. See the source code.
To demonstrate how to use Spring wiring with ORMLite, this little program includes classes and XML configuration files. See the source code.
This example shows how to define custom data persisters with ORMLite which can change how data types are stored in the database. See the source code.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
For Android developers, here some complete example application projects to help you get started. See here for tarballs of all of the packages as well as code links.
A basic Android application which does some database operations and then quits.
A nice little application written by Kevin G. that provides a counter type application using ORMLite.
An example of a service application that uses ORMLite written by Kevin G.
This is similar to the HelloAndroid example but it is using JDBC and H2 instead of the build-in Android database calls. This is more
a proof of concept rather than a true example. The wiring for the onCreate
and onUpdate
is a hack. H2 is certainly
larger, has tons more features, but is slower than the native SQLite. Also, JDBC under Android is not completely sanctioned by
Google and support for it may be removed in the future.
This is similar to the HelloAndroid example but its activity does not extend the OrmLiteBaseActivity
but instead manages the
helpers itself. Certain programmers may want to manage the database connections using their own code to better share between
activities and services or to use ORMLite when it is not possible to extend the base classes.
This is similar to the HelloAndroid example but it uses two separate databases, manages the helpers itself, and does not
use the OpenHelperManager
to manage the helpers at all. This is one way that you can deal with two different databases.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
There are a number of people who have helped with this project. If I’ve forgotten you please remind me so I can add you to this list. Let me know if you’d like to tune your name or add link to your home page here as well.
Thanks much to them all.
DAO
interface and the BaseDaoImpl
where in some part modeled after his code.
Thanks much to them all.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document is part of the ORMLite project.
Copyright 2021, Gray Watson
Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that this permission notice appear in all copies.
 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| Jump to: | !
<
=
>
@
A B C D E F G H I J K L M N O P Q R S T U V W X Z |
|---|
| Jump to: | !
<
=
>
@
A B C D E F G H I J K L M N O P Q R S T U V W X Z |
|---|
| [Top] | [Contents] | [Index] | [ ? ] |
| [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Gray Watson on December 20, 2021 using texi2html 1.82.
The buttons in the navigation panels have the following meaning:
| Button | Name | Go to | From 1.2.3 go to |
|---|---|---|---|
| [ < ] | Back | Previous section in reading order | 1.2.2 |
| [ > ] | Forward | Next section in reading order | 1.2.4 |
| [ << ] | FastBack | Beginning of this chapter or previous chapter | 1 |
| [ Up ] | Up | Up section | 1.2 |
| [ >> ] | FastForward | Next chapter | 2 |
| [Top] | Top | Cover (top) of document | |
| [Contents] | Contents | Table of contents | |
| [Index] | Index | Index | |
| [ ? ] | About | About (help) |
where the Example assumes that the current position is at Subsubsection One-Two-Three of a document of the following structure:
This document was generated by Gray Watson on December 20, 2021 using texi2html 1.82.


EUR/USD loses the grip post-IFO, back near 1.1020
by Pablo Piovano- EUR/USD fades the uptick to 1.1030/35.
- German Business Climate matched estimates at 95.0.
- Bund 10-year yield advances to -0.35%.
EUR/USD is now returning to the 1.1020 region after failing to sustain the earlier advance to session highs in the 1.1030/35 band.
EUR/USD upside still capped by the 55-day SMA
Spot is now losing some upside momentum after the German IFO survey failed to surprise investors on Monday.
In fact, the pair remained apathetic after the German Business Climate improved marginally to 95.0 for the current month and the Current Assessment came in at 97.9, both prints matching initial estimates. On the downbeat side, Business Expectations came in at 92.1, missing consensus albeit also improving a tad from October’s 91.6.
Later in the week, investors’ attention is expected to be on the preliminary inflation figures in both Germany and the broader euro area for the month of November.
What to look for around EUR
Spot has been rejected from the vicinity of the 1.1100 barrier once again last week, sparking the subsequent knee-jerk to the vicinity of the critical support at 1.10 the figure. As always, EUR is expected to keep tracking trade headlines and USD-dynamics for the time being. On the more macro view, the outlook in Euroland remains fragile and does nothing but justify the ‘looser for longer’ monetary stance by the ECB and the cautious view on the European currency in the medium term. In this regard, latest estimates from manufacturing PMIs in the euro region hint at the likeliness that the sector appear to have bottomed out, although the contagion to the services sector looks more evident as it gained extra pace.
EUR/USD levels to watch
At the moment, the pair is gaining 0.02% at 1.1020 and faces the next hurdle at 1.1083 (100-day SMA) followed by 1.1097 (monthly high Nov.21) and finally 1.1171 (200-day SMA). On the downside, a break below 1.0989 (monthly low Nov.14) would target 1.0925 (low Sep.3) en route to 1.0879 (2019 low Oct.1).


module ActiveRecord::Querying
Public Instance Methods
Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part. The use of this method should be restricted to complicated SQL queries that can't be executed using the ActiveRecord::Calculations class methods. Look into those before using this.
Parameters¶ ↑
-
sql
- An SQL statement which should return a count query from the database, see the example below.Product.count_by_sql “SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id”
# File lib/active_record/querying.rb, line 63 def count_by_sql(sql) sql = sanitize_conditions(sql) connection.select_value(sql, "#{name} Count").to_i end
Executes a custom SQL query against your database and returns all the
results. The results will be returned as an array with columns requested
encapsulated as attributes of the model you call this method from. If you
call Product.find_by_sql
then the results will be returned in
a Product
object with the attributes you specified in the SQL
query.
If you call a complicated SQL query which spans multiple tables the columns specified by the SELECT will be attributes of the model, whether or not they are columns of the corresponding table.
The sql
parameter is a full SQL query as a string. It will be
called as is, there will be no database agnostic conversions performed.
This should be a last resort because using, for example, MySQL specific
terms will lock you to using that particular database engine or require you
to change your call if you switch engines.
# A simple SQL query spanning multiple tables Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id" # => [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...]
You can use the same string replacement techniques as you can with
ActiveRecord::QueryMethods#where
:
Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date] Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
# File lib/active_record/querying.rb, line 38 def find_by_sql(sql, binds = []) result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds) column_types = result_set.column_types.dup columns_hash.each_key { |k| column_types.delete k } message_bus = ActiveSupport::Notifications.instrumenter payload = { record_count: result_set.length, class_name: name } message_bus.instrument('instantiation.active_record', payload) do result_set.map { |record| instantiate(record, column_types) } end end


Welcome to Quickupload!
This service let's you upload files with one line.
To upload your files, use the following command:


{% extends 'base.html' %} {% block content %}
This is a simple complain and suggestion app built with Django 3 and bootstrap 4. In this application, You do not need to add your information.
It helps to make us better.
Submit Complain Submit Suggestion


- onAdd() - Method in class ca.ualberta.cs.oneclick_cookbook.AddIngredientsActivity
-
Function that is called when the user clicks the add ingredient button.
- onAdd() - Method in class ca.ualberta.cs.oneclick_cookbook.ManagePantryActivity
-
Function that is called when the user clicks the add ingredient button.
- onAddIngredients() - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
Function that is called when the user clicks on the add ingredients
button.
- onAddPhoto() - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
Function that is called when the user clicks on the add photo button.
- onAddPhoto() - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFullRecipeActivity
-
Function that is called when the user clicks on the add photo button.
- onCreate(Bundle) - Method in class ca.ualberta.cs.oneclick_cookbook.DeleteCache
-
- onCreate() - Method in class ca.ualberta.cs.oneclick_cookbook.GlobalApplication
-
- onCreate(Bundle) - Method in class ca.ualberta.cs.oneclick_cookbook.MainActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.AddIngredientsActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.ChooseAddFriendActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.ChooseSendMethodActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.EditFriendInfoActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.EnterFriendActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.KeywordSearchActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.LoginActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.MainActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.ManageFriendsActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.ManagePantryActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.NotificationsActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.SearchActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.SearchUsersActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.SendEmailActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.SendToFriendActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.SignUpActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFavoriteRecipeActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFullRecipeActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.ViewRecievedRecipeActivity
-
- onCreateOptionsMenu(Menu) - Method in class ca.ualberta.cs.oneclick_cookbook.ViewRecipesActivity
-
- onDelete() - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
Function that is called when the user clicks on the delete button of the
recipe.
- onDelete() - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFullRecipeActivity
-
Function that is called when the user clicks on the delete button of the
recipe.
- onDeleteAll() - Method in class ca.ualberta.cs.oneclick_cookbook.AddIngredientsActivity
-
Function that is called when the user clicks on the delete all button.
- onDeleteAll() - Method in class ca.ualberta.cs.oneclick_cookbook.ManagePantryActivity
-
Function that is called when the user clicks on the delete all button.
- onDeleteAll() - Method in class ca.ualberta.cs.oneclick_cookbook.ViewRecipesActivity
-
Function that is called when the user clicks delete all from the view
recipe screen.
- onDone() - Method in class ca.ualberta.cs.oneclick_cookbook.AddIngredientsActivity
-
Function that is called when the user clicks done.
- onDone() - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
Function that is called when the user clicks on the done button of the
recipe.
- onDone() - Method in class ca.ualberta.cs.oneclick_cookbook.ManagePantryActivity
-
Function that is called when the user clicks done.
- onDone() - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFullRecipeActivity
-
Function that is called when the user clicks on the done button of the
recipe.
- onKeyDown(int, KeyEvent) - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
Overides the back key action.
- onKeyDown(int, KeyEvent) - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFullRecipeActivity
-
Overides the back key action.
- onLogin() - Method in class ca.ualberta.cs.oneclick_cookbook.LoginActivity
-
Function that is called when the user logs in.
- onLowMemory() - Method in class ca.ualberta.cs.oneclick_cookbook.GlobalApplication
-
- onNextPhoto() - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
Function that is called when the user clicks on the image button.
- onNextPhoto() - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFullRecipeActivity
-
Function that is called when the user clicks on the image button.
- onRemovePhoto() - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
Function that is called when the user clicks on the remove photo button.
- onRemovePhoto() - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFullRecipeActivity
-
Function that is called when the user clicks on the remove photo button.
- onResume() - Method in class ca.ualberta.cs.oneclick_cookbook.AddIngredientsActivity
-
- onResume() - Method in class ca.ualberta.cs.oneclick_cookbook.CreateRecipeActivity
-
- onResume() - Method in class ca.ualberta.cs.oneclick_cookbook.MainActivity
-
Function that is called when the user resumes on the main screen.
- onResume() - Method in class ca.ualberta.cs.oneclick_cookbook.ManagePantryActivity
-
- onResume() - Method in class ca.ualberta.cs.oneclick_cookbook.ViewFullRecipeActivity
-
- onResume() - Method in class ca.ualberta.cs.oneclick_cookbook.ViewRecipesActivity
-
- onSignUp() - Method in class ca.ualberta.cs.oneclick_cookbook.SignUpActivity
-
Commits the signup of the user, based on the info they have entered.


Plugin Information |
|---|
View Sofy.AI on the plugin site for more information. |
The current version of this plugin may not be safe to use. Please review the following warnings before use:
This plugin allows you to conduct Tests for your Website and Mobile Application Builds, right from your Jenkins Pipelines, using your Sofy account
Documentation
For instructions on how to install and use this plugin, please visit the Sofy Jenkins Help page


Lucknow, Kolkata, Mumbai, Delhi
On duty: 24/7
email for any query
We provide instant Ambulance's services according to your location and urgency with all basic but important necessities to ensure the paramedics are prepared for almost any situation! Lives are precious!
Build by Bisudh - Infinity Health


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Smarter Spaces
Mailing Address:
P.O. Box 88736175 Almon St
HALIFAX, Nova Scotia
B3K 5M4
Location Address:
201A-5571 Cunard StHALIFAX, Nova Scotia
B3K 1C5
Tel.:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
Logo
Company Profile
Smarter Spaces Scans, Plans and Relocates spaces. Utilizing the latest Mobile 3D Laser Scanning technology we produce 2D and 3D AutoCAD and/or Revit files of your buildings providing accurate and up to date As-built / As-scanned drawings for exiting building or new. We also work in the field of Volumetrics producing volume calculation for salt, gravel, wood chips and more. Our technology shoots 43,000 points per second and is accurate +/- 3mm with a range of 30 meters inside and 15 meters outside. We are certified to do BOMA Measure packages and specialize in Fire Safety Plans and Evacuation maps. Recent projects include Irving Shipyards, Killam Properties, Crombie Reit, Red Cross Jazz Aviation, Acadia University and City of Halifax.
Full profile
Full profile
Contact information
Company description
541360 - Geophysical Surveying and Mapping Services
541370 - Surveying and Mapping (except Geophysical) Services
541490 - Other Specialized Design Services
541690 - Other Scientific and Technical Consulting Services
561490 - Other Business Support Services
Product / Service / Licensing
Clear benefits obtained from working with SMARTER SPACES and our 3D Scanning capabilities is very quick turn-around time, incredibly accurate measurements, processed in house by us. FAST – ACCURATE – EFFICIENT
Our advanced 3D laser technology captures airborne lidar data which provides detailed statistics and area coverage point clouds.
Data Acquisition Speed 43,200 Measurement points/second
3D Measurement Accuracy – +/- 0.1% (3 mm)
Maximum Range Up to 30m (15m outdoors)
Laser Safety Class Class 1 Eye Safe
Angular Field of View 270x 100 degrees
IP64 rating splash-proof, dust-tight
Our 3D Scanning technology is one of the most mobile and accurate systems in the world. It is lightweight, sturdy, splashproof and accurate. It is carried in a backpack and held by hand making stairs, compact spaces, and complicated layouts easy. Smarter Spaces’ scans are 10 times faster than traditional laser measures and much more accurate.
Buildings: Architectural, Engineering and Construction (AEC)
As-built / As-scanned Drawings in AutoCAD or Revit
BOMA Analysis and Space Certificates
Office
Retail
Industrial
Multi-unit
Scan to BIM
Fire Evacuation Mapping
Mapping of Heritage properties
Cave and Mine Mapping
The 3D Scanning technology we employ does not require GPA and works well underground. With its light weight, compactness and ease of use it is ideal for:
Cave mapping
Mine mapping
Volumetrics & Stockpiles
SMARTER SPACES 3D scanning technology is ideal for doing inventory, stockpiles and volumetrics calculations providing accuracy with incredible turn around times. The resulting data providing accuracy in inventory not possible in the past.
Forestry
Management of Forestry Resources
Mapping and counting of trees
Law Enforcement & Security
The ease of use, mobility and accuracy provided by the 43,200 points per second makes Smarter Spaces 3D scanning abilities ideally suited for law enforcement and security:
Accident recreation
Mapping of crime scenes
Threat assessment
Emergency measures and response using 3D point clouds
Whether a crime scene needs detailed assessment, or a road vehicle incident requires rapid capture, our systems are uniquely placed to do the job.
Coastal Erosion Monitoring
Our technology is ideally suited for recurring measures to monitor erosion in coastal areas.
Our approach is to scan your space using a variety of technology application- 3D Laser Scanner, Laser Distance Measurer, Tablet interface solutions. We design your floor plans using Revit Architecture and AutoCAD Architecture software applications.
Our detailed BOMA analysis reports consist of:
Explanation of the BOMA Standard applied and critical definitions
Global Summary of Areas Spreadsheet
Detailed Accurate Dimensioned floor plan with outlines of tenant areas including interior layouts.
Space / Area Certificates
Optional – Hard and or Electronic copies
About BOMA
In 1915, BOMA International published the first Standard Method of Floor Measurement for Office Buildings. It has been accepted and approved by the American National Standards Institute. Throughout the years, the standard has been revised to reflect the changing needs of the real estate market and the evolution of office building design.
This latest version, Office Buildings: Standard Methods of Measurement (ANSI/BOMA Z65.1 – 2010), provides a uniform basis for measuring rentable area in both existing and new office buildings by taking a building-wide approach to floor area measurement. It provides a methodology for measuring both occupant space as well as the space that benefits all occupants.
What are evacuation maps?
Our illustrations inform and guide both staff and the public out of a facility safely in the event of an emergency. These evacuation maps outline building emergency procedures, locations of critical emergency equipment and help users identify where their point of origin is and where to find an appropriate exit.
Format and style options
We have a variety of predefined template styles on file or we can custom design a look and feel to meet your brand requirements.
Typical format sizing includes- 5”x7”, 8”x10”, 8.5”x11”, 11”x17”. Larger custom formats are also available. From Professional high quality color prints, to Photoluminescent and Tactile solutions — we do it all!
We can also produce facility illustrations for placement adjacent to facility fire panels for first responders.
Framing and mounting
We offer a variety of economical priced and modern casement solutions to choose from to meet your budget. Including- Laminated, Ultraboard, AluPanel, Plaque Mount, and Snap Frames. Various sizes and colors available.
Local & national regulatory compliance
Prior to submitting the final product to our clients in part with our quality assurance guarantee and due-diligence, we will provide electronic copies to the local industry authorities (Fire Inspector, Fire Marshall Office) to validate our maps are in compliance with local and national codes and regulations. This provides a level of added value to our clients.
Smarter Spaces has extensive experience in evacuation mapping
Smarter Spaces has provided evacuation mapping solutions for a variety of facility types including- law enforcement ; fire departments ; hospitals; medical offices ; small medium large business offices; libraries; arenas; community centers; auditoriums; lecture halls; gymnasia; indoor swimming pools… just to name a few.
One of Smarter Spaces’s Fire Safety Plan specialists will meet with your facility operational prime(s) and conduct a detailed analysis of the facilities fire safety systems, equipment and procedures in a building to protect people from fire. In preparing draft and final versions of the fire safety plan other areas of information capture will include (but not limited to):
Building Resource Summary
Human Resources
Emergency Procedures for Occupants
Emergency Procedures for Supervisory Staff
Responsibilities of the Owner / Occupant
Fire hazards
Fire Extinguisher, Control or Confinement
Alternate measures for Occupant Fire Control
Other requirements under the National Fire Code that we will cover off include but not limited to:
General Fire protection Systems / Equipment
Portable Fire Extinguishers
Fire Alarm
Smoke Alarm
Standpipe Systems
Sprinkler Systems (Wet)
Sprinkler Systems (Dry)
Water Supplies for Firefighting (Private Hydrant)
Water Supplies for Firefighting (Water Pump)
Water Supplies for Firefighting (Water tanks)
Smoke Shafts and Venting Equipment
Smoke Control Measures
Commercial Cooking Equipment
Emergency Power Systems
We manage and execute corporate moves
We make moves seamless and straight forward
Keep your staff focused on core roles and work responsibilities
Save money, time and eliminate stress…
What we do
A common mistake many companies make is in the belief that by managing their relocation themselves they will save money; the general thought being how hard can it be to get the business from point A to point B? Companies proceed to assign an internal resource who doesn’t have the expertise, focus, or time; the resource is able to get them to point B. They have arrived at their new location with a dysfunctional business, unhappy staff created by the confusion and chaos, and it has cost them double what it should have in additional cost, overruns of an unrealistic budget, and loss of productivity. This can be avoided by hiring a professional with the knowledge and expertise to create a strategic plan to execute a cost effective and well organized relocation.
Keeping relocation’s on-time and on-plan
Smarter Spaces has extensive experience in relocating office infrastructure and company assets. We work directly with our clients to develop a plan for the relocation of staff, office furniture, phones, computers, servers, network and telecommunications equipment and services.
Our approach to office relocation’s
Whether you’re opening a new office, relocating an existing one, or managing day-to-day moves in your current office, we can provide you with the right resources and expertise for your needs. We work with you to develop a schedule, budget, and strategic plans of action so that you have a clear understanding of all the requirements to move your business, business divisions, and/or departments. We get the job done right the first time – minimizing rework and reducing costs.
How does it work?
Smarter Spaces develops everything from budgetary numbers to critical vendor requirements, RFP development and analysis, to vendor selection and on-site implementation and management vital to a successful relocation plan, or move-in to a new office space. We offer turnkey facility solutions from initial design to occupancy of the facility by ensuring everything is completed as planned and on time. During execution we are the first ones onsite and the last to leave!
We coordinate many aspects of a move, including:
Planning and scheduling of the move – We are the first ones on site and the last to leave.
Employee coordination, communications, and liaison. We recognize relocation can be a very emotional process.
Furnishings: Workstations, cubicles, desks, executive office furniture office suites, filing, and storage; we have done it all and know how to inventory it, tag it and relocate it.
Electrical: Workstations, cubicles, office suites and copy centers and additional offices
Structured Wiring & Communications: Voice, Data, VOIP Equipment: computers, printers, faxes, servers etc.
Clean Up: We manage the commercial moving and cleaning – these are important details that help minimize launch day challenges.
Smarter Spaces’s Relocations expertise
We bring our strong relationships with experienced vendors and business partners to relocation projects we manage. We maintain a resource base of consistent best-of-class vendors and professional resources across Atlantic Canada and know their products and services inside out; this knowledge is key to the success of many construction and relocation projects for our clients.
R019-Other Professional Services
Technology profile
Market profile
Alliances:
- Sales/Marketing
- Technology
Strategic alliances:
Leading Mobile 3D Laser Scanning TechnologyIndustry sector market interests:
- Agriculture
- Construction
- Consumer Products
- Culture
- Environment
- Fishery
- Forestry
- Information Technology and Telecommunications
- Manufacturing
- Medical/Biotechnology/Chemical
- Mining/Petroleum/Gas
- Service Industry
- Tourism
- Transportation
- Wholesale/Retail
- Aerospace
- Defence
- Automotive
- Food and Beverage Manufacturing
- Furniture and Wood Product
- Pulp and Paper
- Plastics and Rubber Products
- Primary and Fabricated Metal
- Electrical Equipment
- Textile and Clothing
Geographic markets:
Actively pursuing:
- United States
- Massachusetts
Sector information
Distribution of employees:
NS - 5Partners across the country
Unique applications:
Our Mobile 3D Laser Scanning Technology is carried in a backpack, shoots 43,000 points per second, accurate +/- 3mm, with a range of 30 meters indoors and 15 meters outdoors. Captures everything from building interiors to piles of salt.Key / Major clients:
Irving Shipyards, Dalhousie University, Red Cross, McInness Cooper, Jazz Aviation, Bell Aliant, Bell Canada, Halifax Regional Municipality, South Shore Regional Schoo lboard, Tri-County Regional School Board, Pictou County Health Authority, Guysborough Antigonish Strait Health Authority, Credit Unit, Crombie Reit, Fortis, Dalhousie University, Acadia UniversitySuccess stories:
Innovative Technology company and the first to Bring Mobile 3D Laser Scanning Technology to Atlantic Canada and Possible all of Canada.Testimonial:
"It makes my job easier and in the end to not leave me with dissatisfied people. It has relieved the pressure and freed up my some of my thinking so I could focus on what I needed to."- Ruby Knowles, Former Vice President, Pictou County Health Authority
"I am certain the move to our new office would not have turned out as well without the leadership they provided throughout the process."
- Gina McFetridge, Vice President, Archway Insurance
"Smarter Spaces was very hands on, jumping in to take care of any new tasks identified, and went above and beyond numerous times."
- Donna Bourque, CPA, CA VP Finance & Admin Innovacorp
"We are confident in their communication skills and they are one of the few consultants that we allow to work directly with end users"
- Terry Gallagher, Manager Corporate Facility Design and Construction, City of Halifax
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
541360 - Geophysical Surveying and Mapping Services
541370 - Surveying and Mapping (except Geophysical) Services
541490 - Other Specialized Design Services
541690 - Other Scientific and Technical Consulting Services
561490 - Other Business Support Services
Products, services and licensing
Product / Service / Licensing
Clear benefits obtained from working with SMARTER SPACES and our 3D Scanning capabilities is very quick turn-around time, incredibly accurate measurements, processed in house by us. FAST – ACCURATE – EFFICIENT
Our advanced 3D laser technology captures airborne lidar data which provides detailed statistics and area coverage point clouds.
Data Acquisition Speed 43,200 Measurement points/second
3D Measurement Accuracy – +/- 0.1% (3 mm)
Maximum Range Up to 30m (15m outdoors)
Laser Safety Class Class 1 Eye Safe
Angular Field of View 270x 100 degrees
IP64 rating splash-proof, dust-tight
Our 3D Scanning technology is one of the most mobile and accurate systems in the world. It is lightweight, sturdy, splashproof and accurate. It is carried in a backpack and held by hand making stairs, compact spaces, and complicated layouts easy. Smarter Spaces’ scans are 10 times faster than traditional laser measures and much more accurate.
Buildings: Architectural, Engineering and Construction (AEC)
As-built / As-scanned Drawings in AutoCAD or Revit
BOMA Analysis and Space Certificates
Office
Retail
Industrial
Multi-unit
Scan to BIM
Fire Evacuation Mapping
Mapping of Heritage properties
Cave and Mine Mapping
The 3D Scanning technology we employ does not require GPA and works well underground. With its light weight, compactness and ease of use it is ideal for:
Cave mapping
Mine mapping
Volumetrics & Stockpiles
SMARTER SPACES 3D scanning technology is ideal for doing inventory, stockpiles and volumetrics calculations providing accuracy with incredible turn around times. The resulting data providing accuracy in inventory not possible in the past.
Forestry
Management of Forestry Resources
Mapping and counting of trees
Law Enforcement & Security
The ease of use, mobility and accuracy provided by the 43,200 points per second makes Smarter Spaces 3D scanning abilities ideally suited for law enforcement and security:
Accident recreation
Mapping of crime scenes
Threat assessment
Emergency measures and response using 3D point clouds
Whether a crime scene needs detailed assessment, or a road vehicle incident requires rapid capture, our systems are uniquely placed to do the job.
Coastal Erosion Monitoring
Our technology is ideally suited for recurring measures to monitor erosion in coastal areas.
Our approach is to scan your space using a variety of technology application- 3D Laser Scanner, Laser Distance Measurer, Tablet interface solutions. We design your floor plans using Revit Architecture and AutoCAD Architecture software applications.
Our detailed BOMA analysis reports consist of:
Explanation of the BOMA Standard applied and critical definitions
Global Summary of Areas Spreadsheet
Detailed Accurate Dimensioned floor plan with outlines of tenant areas including interior layouts.
Space / Area Certificates
Optional – Hard and or Electronic copies
About BOMA
In 1915, BOMA International published the first Standard Method of Floor Measurement for Office Buildings. It has been accepted and approved by the American National Standards Institute. Throughout the years, the standard has been revised to reflect the changing needs of the real estate market and the evolution of office building design.
This latest version, Office Buildings: Standard Methods of Measurement (ANSI/BOMA Z65.1 – 2010), provides a uniform basis for measuring rentable area in both existing and new office buildings by taking a building-wide approach to floor area measurement. It provides a methodology for measuring both occupant space as well as the space that benefits all occupants.
What are evacuation maps?
Our illustrations inform and guide both staff and the public out of a facility safely in the event of an emergency. These evacuation maps outline building emergency procedures, locations of critical emergency equipment and help users identify where their point of origin is and where to find an appropriate exit.
Format and style options
We have a variety of predefined template styles on file or we can custom design a look and feel to meet your brand requirements.
Typical format sizing includes- 5”x7”, 8”x10”, 8.5”x11”, 11”x17”. Larger custom formats are also available. From Professional high quality color prints, to Photoluminescent and Tactile solutions — we do it all!
We can also produce facility illustrations for placement adjacent to facility fire panels for first responders.
Framing and mounting
We offer a variety of economical priced and modern casement solutions to choose from to meet your budget. Including- Laminated, Ultraboard, AluPanel, Plaque Mount, and Snap Frames. Various sizes and colors available.
Local & national regulatory compliance
Prior to submitting the final product to our clients in part with our quality assurance guarantee and due-diligence, we will provide electronic copies to the local industry authorities (Fire Inspector, Fire Marshall Office) to validate our maps are in compliance with local and national codes and regulations. This provides a level of added value to our clients.
Smarter Spaces has extensive experience in evacuation mapping
Smarter Spaces has provided evacuation mapping solutions for a variety of facility types including- law enforcement ; fire departments ; hospitals; medical offices ; small medium large business offices; libraries; arenas; community centers; auditoriums; lecture halls; gymnasia; indoor swimming pools… just to name a few.
One of Smarter Spaces’s Fire Safety Plan specialists will meet with your facility operational prime(s) and conduct a detailed analysis of the facilities fire safety systems, equipment and procedures in a building to protect people from fire. In preparing draft and final versions of the fire safety plan other areas of information capture will include (but not limited to):
Building Resource Summary
Human Resources
Emergency Procedures for Occupants
Emergency Procedures for Supervisory Staff
Responsibilities of the Owner / Occupant
Fire hazards
Fire Extinguisher, Control or Confinement
Alternate measures for Occupant Fire Control
Other requirements under the National Fire Code that we will cover off include but not limited to:
General Fire protection Systems / Equipment
Portable Fire Extinguishers
Fire Alarm
Smoke Alarm
Standpipe Systems
Sprinkler Systems (Wet)
Sprinkler Systems (Dry)
Water Supplies for Firefighting (Private Hydrant)
Water Supplies for Firefighting (Water Pump)
Water Supplies for Firefighting (Water tanks)
Smoke Shafts and Venting Equipment
Smoke Control Measures
Commercial Cooking Equipment
Emergency Power Systems
We manage and execute corporate moves
We make moves seamless and straight forward
Keep your staff focused on core roles and work responsibilities
Save money, time and eliminate stress…
What we do
A common mistake many companies make is in the belief that by managing their relocation themselves they will save money; the general thought being how hard can it be to get the business from point A to point B? Companies proceed to assign an internal resource who doesn’t have the expertise, focus, or time; the resource is able to get them to point B. They have arrived at their new location with a dysfunctional business, unhappy staff created by the confusion and chaos, and it has cost them double what it should have in additional cost, overruns of an unrealistic budget, and loss of productivity. This can be avoided by hiring a professional with the knowledge and expertise to create a strategic plan to execute a cost effective and well organized relocation.
Keeping relocation’s on-time and on-plan
Smarter Spaces has extensive experience in relocating office infrastructure and company assets. We work directly with our clients to develop a plan for the relocation of staff, office furniture, phones, computers, servers, network and telecommunications equipment and services.
Our approach to office relocation’s
Whether you’re opening a new office, relocating an existing one, or managing day-to-day moves in your current office, we can provide you with the right resources and expertise for your needs. We work with you to develop a schedule, budget, and strategic plans of action so that you have a clear understanding of all the requirements to move your business, business divisions, and/or departments. We get the job done right the first time – minimizing rework and reducing costs.
How does it work?
Smarter Spaces develops everything from budgetary numbers to critical vendor requirements, RFP development and analysis, to vendor selection and on-site implementation and management vital to a successful relocation plan, or move-in to a new office space. We offer turnkey facility solutions from initial design to occupancy of the facility by ensuring everything is completed as planned and on time. During execution we are the first ones onsite and the last to leave!
We coordinate many aspects of a move, including:
Planning and scheduling of the move – We are the first ones on site and the last to leave.
Employee coordination, communications, and liaison. We recognize relocation can be a very emotional process.
Furnishings: Workstations, cubicles, desks, executive office furniture office suites, filing, and storage; we have done it all and know how to inventory it, tag it and relocate it.
Electrical: Workstations, cubicles, office suites and copy centers and additional offices
Structured Wiring & Communications: Voice, Data, VOIP Equipment: computers, printers, faxes, servers etc.
Clean Up: We manage the commercial moving and cleaning – these are important details that help minimize launch day challenges.
Smarter Spaces’s Relocations expertise
We bring our strong relationships with experienced vendors and business partners to relocation projects we manage. We maintain a resource base of consistent best-of-class vendors and professional resources across Atlantic Canada and know their products and services inside out; this knowledge is key to the success of many construction and relocation projects for our clients.
R019-Other Professional Services
Technology
Technology profile
Market
Market profile
Alliances:
- Sales/Marketing
- Technology
Strategic alliances:
Leading Mobile 3D Laser Scanning TechnologyIndustry sector market interests:
- Agriculture
- Construction
- Consumer Products
- Culture
- Environment
- Fishery
- Forestry
- Information Technology and Telecommunications
- Manufacturing
- Medical/Biotechnology/Chemical
- Mining/Petroleum/Gas
- Service Industry
- Tourism
- Transportation
- Wholesale/Retail
- Aerospace
- Defence
- Automotive
- Food and Beverage Manufacturing
- Furniture and Wood Product
- Pulp and Paper
- Plastics and Rubber Products
- Primary and Fabricated Metal
- Electrical Equipment
- Textile and Clothing
Geographic markets:
Actively pursuing:
- United States
- Massachusetts
Sector
Sector information
Distribution of employees:
NS - 5Partners across the country
Unique applications:
Our Mobile 3D Laser Scanning Technology is carried in a backpack, shoots 43,000 points per second, accurate +/- 3mm, with a range of 30 meters indoors and 15 meters outdoors. Captures everything from building interiors to piles of salt.Key / Major clients:
Irving Shipyards, Dalhousie University, Red Cross, McInness Cooper, Jazz Aviation, Bell Aliant, Bell Canada, Halifax Regional Municipality, South Shore Regional Schoo lboard, Tri-County Regional School Board, Pictou County Health Authority, Guysborough Antigonish Strait Health Authority, Credit Unit, Crombie Reit, Fortis, Dalhousie University, Acadia UniversitySuccess stories:
Innovative Technology company and the first to Bring Mobile 3D Laser Scanning Technology to Atlantic Canada and Possible all of Canada.Testimonial:
"It makes my job easier and in the end to not leave me with dissatisfied people. It has relieved the pressure and freed up my some of my thinking so I could focus on what I needed to."- Ruby Knowles, Former Vice President, Pictou County Health Authority
"I am certain the move to our new office would not have turned out as well without the leadership they provided throughout the process."
- Gina McFetridge, Vice President, Archway Insurance
"Smarter Spaces was very hands on, jumping in to take care of any new tasks identified, and went above and beyond numerous times."
- Donna Bourque, CPA, CA VP Finance & Admin Innovacorp
"We are confident in their communication skills and they are one of the few consultants that we allow to work directly with end users"
- Terry Gallagher, Manager Corporate Facility Design and Construction, City of Halifax


Panic! At The Disco‘s new album Pray For The Wicked was originally going to be named after a Lord Byron quote: “Fame is the thirst of youth.”
Panic! At The Disco’ frontman Brendon Urie is one of the most irrepressible characters in music, and nothing sums that up better than new album Pray For the Wicked; the follow-up to the band’s first number one album, 2016’s Death Of A Bachelor.
As any stan of Halsey or Panic! At The Disco's Brendon Urie will know, the friendship between the pair goes way back.
Fans show a lot of love to Panic! At The Disco and, as it turns out, the love goes both ways. Panic! road manager Zack Hall shared a post on Instagram explaining how a fan/photographer named Stephanie Estrada got to shoot some amazing photos.
Yours truly is gracing the cover of @RockSound as Artist of the Year, and what a year it’s been 😍 available now on https://t.co/498uqwzwFE pic.twitter.com/wNeAy4z8yt
— Panic! At The Disco (@PanicAtTheDisco) November 30, 2018
Your new favorite jam 🌹🌹🌹 Roses with @ItsBennyBlanco + @JuiceWorlddd out now https://t.co/DLm3bPk8mN pic.twitter.com/v39YcglMpG
— Panic! At The Disco (@PanicAtTheDisco) December 5, 2018
.@PanicAtTheDisco earns second straight Alternative Songs No. 1, with "High Hopes" https://t.co/b2b74lEFY8 [via @billboardcharts] pic.twitter.com/pMuAIAkiwk
— billboard (@billboard) November 13, 2018


How to play
This game contains two game modes. In both, the goal of the game is to swap shells in order to make matches and score points. Click on two adjacent shells, or drag from one to the other, in order to make a swap.Shariki
Russian for "Balloons", Shariki is the original "match-three" puzzle game.Make a row or column of 3+ shells to clear them and score points.
Each swap must make a match, or it is not allowed.
Bombi
Russian for "Bombs", Bombi is a new puzzle game.Arrange shells of the same color into a 2x2 square in order to create a bomb.
When the bomb's timer reaches zero, it will destroy nearby shells of the same color, and bombs of any color.
The numbers on each shell signify two things:
- A bomb's timer is the sum of the numbers on the shells that created it.
- A bomb's blast radius is the lowest number on the shells that created it.
Click on a bomb to see its blast radius.
Credits
Rakushki was created by the Oswego CSC380 team, IRONKLADD. KLADD is an abbreviation for the team's members: Kenny Roffo, Hsueh Kuan Lu, Alexander Jansing, Dean Tupper, and Daniel Wysocki.The game logo was contributed by Brandon Caruso.
The game was written in JavaScript using StageJS as the graphics engine.