public final class Database extends Object
This package provides methods for creating and loading Derby databases, tailored to the specifications of the end-of-term project for IBAT College Dublin's Advanced Diploma in Computer Programming (Advanced Java) class, for the Autumn 2018 term.
Users can create or load databases with the connect()
method (and disconnect from them with the disconnect()
method):
jshell> import watson.*
jshell> String dbname = "myDatabase"
dbname ==> "myDatabase"
jshell> Optional<Database> optdb = Database.connect(dbname, "bootpass", "owner", "ownerpass")
MESSAGE | connect() : database successfully initialised
optdb ==> Optional[watson.Database@69f63d95]
jshell> Database db = optdb.get()
db ==> watson.Database@69f63d95
In the call to connect()
, above, dbname
is the
name of the database, "bootpass"
is the password to boot the
database, and "owner"
and "ownerpass"
are the username and
password of the user logging into the database (in this case, the owner, as
this database is only just being created. The database name and boot
password are always required to open the database, though the username and
user password may change. Note that the owner of the database cannot be
altered or transferred, so in the above case, "owner" will always be the
owner of this database. Database owners (or DBOs) have certain permissions
that regular users don't have, but they cannot interact with the database
like normal users in that they do not have lists of contacts or groups.
You can manually check if the current user is the database owner by
calling the owner()
and user()
methods, or you
can use the convenience method userIsDBO()
:
jshell> db.owner(); db.user()
$5 ==> Optional[OWNER]
$6 ==> Optional[OWNER]
jshell> db.userIsDBO()
$7 ==> true
The DBO can get a list of all users with the users()
method, and any user can get a list of all tables available to them by
calling the tables()
method. As the DBO can edit any user
and any table, they have access to all of this information:
jshell> db.users(); db.tables()
$8 ==> Optional[[OWNER]]
$9 ==> [OWNER.SECURE]
The DBO only has a SECURE
table, which holds their hashed
password and the salt used during the hashing process (see
PasswordUtils
). Every other non-DBO user also has
a CONTACTS
table, which holds a list of their contacts, and a
GROUPS
table, which holds all of the relationships between the
user's contacts and their groups of contacts. SECURE
tables are, by
default, hidden from non-DBO users. Each non-DBO user can only see their own
CONTACTS
and GROUPS
tables.
Any user (including the DBO) can change their password with the
changePassword()
method:
jshell> db.changePassword("ownerpass", "newpass")
MESSAGE | changePassword() : password successfully changed
$10 ==> true
The user must enter their old password in order to change their password, as a measure of added security.
The DBO can add users to the database by providing a username and a password, and by verifying their own password:
jshell> db.addUser("usera", "userapass", "newpass")
MESSAGE | addUser() : user 'usera' successfully added
$11 ==> true
jshell> db.addUser("userb", "userbpass", "newpass")
MESSAGE | addUser() : user 'userb' successfully added
$12 ==> true
jshell> db.addUser("userc", "usercpass", "newpass")
MESSAGE | addUser() : user 'userc' successfully added
$13 ==> true
jshell> db.users(); db.tables()
$14 ==> Optional[[OWNER, USERA, USERB, USERC]]
$15 ==> [OWNER.SECURE, USERA.CONTACTS, USERA.GROUPS, USERA.SECURE, USERB.CONTACTS, USERB.GROUPS, USERB.SECURE, USERC.CONTACTS, USERC.GROUPS, USERC.SECURE]
The DBO can delete a user with the deleteUser()
method (again, the DBO must re-enter their password as a security
measure):
jshell> db.deleteUser("userb", "newpass")
MESSAGE | deleteUser() : user 'userb' successfully deleted
$16 ==> true
jshell> db.users(); db.tables()
$17 ==> Optional[[OWNER, USERA, USERC]]
$18 ==> [OWNER.SECURE, USERA.CONTACTS, USERA.GROUPS, USERA.SECURE, USERC.CONTACTS, USERC.GROUPS, USERC.SECURE]
Note that usernames are case-insensitive, but passwords (obviously) are
case-sensitive. Passwords cannot be null
, empty, or have any leading
or trailing whitespace characters.
The DBO can reset a user's password (if they forgot it, for instance) by
calling the resetPassword()
method:
jshell> db.resetPassword("usera", "password1", "newpass")
MESSAGE | resetPassword() : password successfully changed
$19 ==> true
To disconnect from the database, close the jshell
or call the
disconnect()
method. You can then log back into the
database as a different user:
jshell> db.disconnect()
jshell> optdb = Database.connect(dbname, "bootpass", "usera", "password1")
MESSAGE | connect() : database successfully initialised
optdb ==> Optional[watson.Database@3e681bc]
jshell> db = optdb.get()
db ==> watson.Database@3e681bc
Non-DBO users can see their own username, the username of the DBO, and
all of the tables available to them. They cannot see other users' tables,
their own SECURE
table, or the list of usernames:
jshell> db.user(); db.owner(); db.tables(); db.users()
$23 ==> Optional[USERA]
$24 ==> Optional[OWNER]
$25 ==> [USERA.CONTACTS, USERA.GROUPS]
ERROR | users() : only database owner can view list of users
$26 ==> Optional.empty
A table can be printed to the terminal with
printTable()
:
jshell> db.printTable("usera.contacts", 15)
| ID | FIRSTNAME | SURNAME | PHONE |
| --------------- | --------------- | --------------- | --------------- |
(The above table is empty, so it's not very exciting at the moment.) The
second argument to printTable()
is the column width.
To add a contact to the CONTACTS
table, create a Contact
object, set some of its fields, and add it to the table with
addContact()
:
jshell> Contact c = new Contact()
c ==>
jshell> c.set("phone", "+3531234567890").set("surname", "watson")
$29 ==> (SURNAME, PHONE) values ('watson', '+3531234567890')
jshell> db.addContact(c)
MESSAGE | addContact() : successfully added contact
$30 ==> true
jshell> db.printTable("usera.contacts", 15)
| ID | FIRSTNAME | SURNAME | PHONE |
| --------------- | --------------- | --------------- | --------------- |
| 1 | | watson | +3531234567890 |
In addition to simply printing tables to the terminal with
printTable()
, the user can get a table as a
List<List<String>>
using table()
. The first row
returned always contains the column headers / labels:
jshell> db.table("usera.contacts")
$31 ==> [[ID, FIRSTNAME, SURNAME, PHONE], [1, null, watson, +3531234567890]]
Setting a field of a Contact
object to null
, an empty
String
, or an all-whitespace String
will set the value of
that field to null
within the database. Setting a field of a
Contact
object which has already been set will overwrite that
field:
jshell> c.set("phone", null).set("firstname", "michael"); db.addContact(c)
$32 ==> (FIRSTNAME, SURNAME) values ('michael', 'watson')
MESSAGE | addContact() : successfully added contact
$33 ==> true
jshell> c.set("phone", "+16109991234").set("firstname", "jessica"); db.addContact(c)
$34 ==> (FIRSTNAME, SURNAME, PHONE) values ('jessica', 'watson', '+16109991234')
MESSAGE | addContact() : successfully added contact
$35 ==> true
jshell> c.set("phone", "+15850001212").set("firstname", "dave").set("surname", " "); db.addContact(c)
$36 ==> (FIRSTNAME, PHONE) values ('dave', '+15850001212')
MESSAGE | addContact() : successfully added contact
$37 ==> true
jshell> c.set("phone", null).set("firstname", "bob").set("surname", "jones"); db.addContact(c)
$38 ==> (FIRSTNAME, SURNAME) values ('bob', 'jones')
MESSAGE | addContact() : successfully added contact
$39 ==> true
jshell> c.set("firstname", "steve").set("surname", "jenkins"); db.addContact(c)
$40 ==> (FIRSTNAME, SURNAME) values ('steve', 'jenkins')
MESSAGE | addContact() : successfully added contact
$41 ==> true
jshell> c.set("surname", "smith"); db.addContact(c)
$42 ==> (FIRSTNAME, SURNAME) values ('steve', 'smith')
MESSAGE | addContact() : successfully added contact
$43 ==> true
jshell> db.printTable("usera.contacts", 15)
| ID | FIRSTNAME | SURNAME | PHONE |
| --------------- | --------------- | --------------- | --------------- |
| 1 | | watson | +3531234567890 |
| 2 | michael | watson | |
| 3 | jessica | watson | +16109991234 |
| 4 | dave | | +15850001212 |
| 5 | bob | jones | |
| 6 | steve | jenkins | |
| 7 | steve | smith | |
Contacts are given a unique, immutable ID number when they're created, and
they can be referenced by this ID number. To update a particular contact,
edit the Contact
object and use the
updateContact()
method:
jshell> c.set("phone", "+16108440000").set("firstname", "andrew").set("surname", "watson")
$45 ==> (FIRSTNAME, SURNAME, PHONE) values ('andrew', 'watson', '+16108440000')
jshell> db.updateContact(1, c)
MESSAGE | updateContact() : contact successfully updated
$46 ==> true
jshell> c.set("phone", "+44567992847").set("surname", "jenkins")
$47 ==> (FIRSTNAME, SURNAME, PHONE) values ('andrew', 'jenkins', '+44567992847')
jshell> db.updateContact(6, c)
MESSAGE | updateContact() : contact successfully updated
$48 ==> true
jshell> db.printTable("usera.contacts", 15)
| ID | FIRSTNAME | SURNAME | PHONE |
| --------------- | --------------- | --------------- | --------------- |
| 1 | andrew | watson | +16108440000 |
| 2 | michael | watson | |
| 3 | jessica | watson | +16109991234 |
| 4 | dave | | +15850001212 |
| 5 | bob | jones | |
| 6 | andrew | jenkins | +44567992847 |
| 7 | steve | smith | |
One or more contacts can be deleted at a time with the
deleteContacts()
method. New contacts continue the
ID numbering sequence, so no ID is ever used twice:
jshell> db.deleteContacts(2, 7)
MESSAGE | deleteContacts() : contacts successfully deleted
$50 ==> true
jshell> c.set("phone", "+44578390838").set("firstname", "mark").set("surname", "twain")
$51 ==> (FIRSTNAME, SURNAME, PHONE) values ('mark', 'twain', '+44578390838')
jshell> db.addContact(c)
MESSAGE | addContact() : successfully added contact
$52 ==> true
jshell> db.printTable("usera.contacts", 15)
| ID | FIRSTNAME | SURNAME | PHONE |
| --------------- | --------------- | --------------- | --------------- |
| 1 | andrew | watson | +16108440000 |
| 3 | jessica | watson | +16109991234 |
| 4 | dave | | +15850001212 |
| 5 | bob | jones | |
| 6 | andrew | jenkins | +44567992847 |
| 8 | mark | twain | +44578390838 |
All user input is sanitised and validated to prevent SQL injection attacks and ensure valid data:
jshell> c.set("phone", "wrong").set("firstname", "; drop tables")
ERROR | set() : phone numbers can only contain digits and '+' signs
ERROR | set() : name fields can only contain letters, spaces, dashes (-) and apostrophes (')
$54 ==> (FIRSTNAME, SURNAME, PHONE) values ('mark', 'twain', '+44578390838')
Contacts can be collected into named groups (group names are case-insensitive):
jshell> db.addToGroup("family", 1, 3, 4)
MESSAGE | addToGroup() : successfully added to group
$55 ==> true
Groups must contain at least one contact. When the last contact in a group is removed, that group no longer exists:
jshell> db.addToGroup("work")
ERROR | addToGroup() : no contact IDs given
$56 ==> false
jshell> db.addToGroup("work", 6, 7, 8)
MESSAGE | addToGroup() : successfully added to group
$57 ==> true
You can see which contacts are in which group(s) by calling
printTable()
on the GROUPS
table:
jshell> db.printTable("usera.groups", 15)
| ID | NAME | CONTACTID |
| --------------- | --------------- | --------------- |
| 1 | FAMILY | 1 |
| 2 | FAMILY | 3 |
| 3 | FAMILY | 4 |
| 4 | WORK | 6 |
| 5 | WORK | 7 |
| 6 | WORK | 8 |
One or more contacts can be removed from a particular group by calling
removeFromGroup()
. Every contact in a group can be
removed from that group by calling deleteGroup()
:
jshell> db.removeFromGroup("work", 7)
MESSAGE | removeFromGroup() : successfully removed from group
$59 ==> true
jshell> db.deleteGroup("family")
MESSAGE | deleteGroup() : successfully deleted group
$60 ==> true
jshell> db.printTable("usera.groups", 15)
| ID | NAME | CONTACTID |
| --------------- | --------------- | --------------- |
| 4 | WORK | 6 |
| 6 | WORK | 8 |
Groups can be renamed with renameGroup()
:
jshell> db.renameGroup("work", "colleagues")
MESSAGE | renameGroup() : successfully renamed group
$62 ==> true
Safeguards are in place to ensure that a particular contact cannot be added to the same group more than once:
jshell> db.addToGroup("colleagues", 6)
WARNING | addToGroup() : user is already associated with group
$63 ==> false
Modifier and Type | Method | Description |
---|---|---|
boolean |
addContact(Contact contact) |
Attempts to add the given
Contact to the list of contacts in the
current user's CONTACTS table. |
boolean |
addToGroup(String groupName,
int... IDs) |
Attempts to add the contacts with the given contact
ID s to the
specified group in the current user's GROUPS table. |
boolean |
addUser(String username,
String password,
String dboPassword) |
Attempts to add a new user to the database with the given
username
and password . |
boolean |
changePassword(String oldPassword,
String newPassword) |
Changes the current user's password.
|
static Optional<Database> |
connect(String databaseName,
String bootPassword,
String userName,
String userPassword) |
|
boolean |
deleteContacts(int... IDs) |
Attempts to delete the contacts with the given contact
ID s from
the current user's CONTACTS and GROUPS tables. |
boolean |
deleteGroup(String groupName) |
Attempts to delete a group from the current user's
GROUPS table
by removing all contacts from that group. |
boolean |
deleteUser(String username,
String dboPassword) |
Attempts to delete the user with the given
username from the
database, along with all of their data. |
static void |
disconnect() |
Closes the connection to the current database, if such a connection
exists; resets all variables.
|
Optional<Contact> |
getContact(int ID) |
Attempts to find the contact with the specified
ID number in the
current user's CONTACTS table and return it as a Contact
object. |
Optional<List<String>> |
groups() |
|
static String |
name() |
Returns the name of the database, or
null if the database has not
yet been initialised. |
Optional<String> |
owner() |
Returns the username of the database owner (DBO), in all-uppercase
letters, wrapped in an
Optional . |
void |
printTable(String tableName,
int columnWidth) |
Prints a table to the standard output device, provided the current user
has permission to view that table.
|
boolean |
removeFromGroup(String groupName,
int... IDs) |
Attempts to remove the contacts with the given contact
ID s from
the specified group in the current user's GROUPS table. |
boolean |
renameGroup(String oldName,
String newName) |
Attempts to rename a group in the current user's
GROUPS table. |
boolean |
resetPassword(String username,
String newPassword,
String dboPassword) |
Sets the password of the user with the given
username to
newPassword , provided that the current user is the DBO. |
List<List<String>> |
table(String tableName) |
Returns the specified table as a
List<List<String>> , provided the
current user has permission to view that table. |
List<String> |
tables() |
Returns a
List containing the names of all user-created tables in
the database accessible by the current user. |
boolean |
updateContact(int ID,
Contact contact) |
Attempts to update the contact with the given contact
ID in the
current user's CONTACTS table by replacing it with the provided
Contact . |
Optional<String> |
user() |
Returns the name of the current user, in all-uppercase letters, wrapped in
an
Optional . |
boolean |
userIsDBO() |
Returns
true if and only if the current user is the database owner. |
Optional<List<String>> |
users() |
Returns an
Optional<List<String>> containing
the names of all users in the database. |
protected boolean |
verifyPassword(String username,
String password) |
Returns
true if and only if the provided username exists
in the database, and the provided password matches that user's
password. |
public static String name()
null
if the database has not
yet been initialised.null
if the database has not
yet been initialised.public static void disconnect()
public static Optional<Database> connect(String databaseName, String bootPassword, String userName, String userPassword)
databaseName
and
returns a reference to that Database
, wrapped in an Optional
.
This class is a singleton class, and databases can only be loaded /
created via this method. Once the database connection has been made, a new
connection cannot be initialised unless the program is terminated. If a
database has already been initialised, this method simply returns a
reference to that database, wrapped in an Optional
.
If the attempt to connect to the database fails, or the default
Statement
and PreparedStatement
s cannot be properly
initialised, this method returns an empty Optional
.
Initialisation can then be re-attempted by the user by again calling
this method.
databaseName
- name of the database to connect to / createbootPassword
- boot password for the database, required to connect to ituserName
- name of the user connecting to / creating the databaseuserPassword
- password for the user specified by userName
Database
object, wrapped in an
Optional
, or an empty Optional
if there was
a problempublic Optional<Contact> getContact(int ID)
ID
number in the
current user's CONTACTS
table and return it as a Contact
object.
Returns Optional#empty an empty Optional
if the ID
doesn't match any contact in the CONTACTS
table or if there was an
SQLException
.
ID
- ID number of the contact to retrieveID
number in the current
user's CONTACTS
table, wrapped in an Optional
, or, if
there was an error, Optional#empty an empty Optional
public boolean addContact(Contact contact)
Contact
to the list of contacts in the
current user's CONTACTS
table.
Returns false
if the contact could not be added to the current
user's CONTACTS
table for any reason. Returns true
if the
contact was successfully added to the current user's CONTACTS
table.
contact
- Contact
to add to the current user's
CONTACTS
tabletrue
if and only if the provided Contact
was
successfully added to the current user's CONTACTS
tabletables(), to see available tables
,
printTable(), to print a particular table to the terminal
,
table(), to get a particular table as a List
public boolean updateContact(int ID, Contact contact)
ID
in the
current user's CONTACTS
table by replacing it with the provided
Contact
.
Returns false
if the contact with the given ID
could
not be updated for any reason. Returns true
if the contact in the
user's CONTACTS
table was successfully replaced by the
Contact
provided as an argument to this method.
ID
- ID index of the contact to update (from the CONTACTS
table)contact
- Contact
which should replace the current contact
with the specified ID
in the current user's CONTACTS
tabletrue
if and only if the contact with the specified
ID
was successfully replaced by the provided Contact
tables(), to see available tables
,
printTable(), to print a particular table to the terminal
,
table(), to get a particular table as a List
public boolean deleteContacts(int... IDs)
ID
s from
the current user's CONTACTS
and GROUPS
tables.
Returns false
if no contacts were deleted (whether due to invalid
ID
numbers, database connectivity problems, or some other issue).
Returns true
if at least one contact was deleted from the current
user's tables as a result of this method.
IDs
- contact ID indices of the contacts to deletetrue
if at least one contact was deleted from the current
user's tablestables(), to see available tables
,
printTable(), to print a particular table to the terminal
,
table(), to get a particular table as a List
public boolean addToGroup(String groupName, int... IDs)
ID
s to the
specified group in the current user's GROUPS
table.
Returns false
if no contacts were added to the specified group
(whether due to an invalid groupName
, invalid ID
numbers,
database connectivity problems, or some other issue). Returns true
if at least one contact was added to the specified group in the current
user's GROUPS
table.
groupName
- name of the group with which the specified contacts should
be associatedIDs
- ID indices of the contacts to add to the specified grouptrue
if at least one contact was added to the specified
grouptables(), to see available tables
,
printTable(), to print a particular table to the terminal
,
table(), to get a particular table as a List
public boolean removeFromGroup(String groupName, int... IDs)
ID
s from
the specified group in the current user's GROUPS
table.
Returns false
if no contacts were removed from the specified
group (whether due to an invalid groupName
, invalid ID
numbers, database connectivity problems, or some other issue). Returns
true
if at least one contact was removed from the specified group
in the current user's GROUPS
table.
groupName
- name of the group from which the specified contacts
should be removedIDs
- ID indices of the contacts to remove from the specified grouptrue
if at least one contact was removed from the
specified grouptables(), to see available tables
,
printTable(), to print a particular table to the terminal
,
table(), to get a particular table as a List
public boolean deleteGroup(String groupName)
GROUPS
table
by removing all contacts from that group.groupName
- name of the group to remove from the current user's
GROUPS
tabletrue
if and only if the specified group was successfully
removed from the current user's GROUPS
table, and no contacts
remain associated with that grouptables(), to see available tables
,
printTable(), to print a particular table to the terminal
,
table(), to get a particular table as a List
public boolean renameGroup(String oldName, String newName)
GROUPS
table.oldName
- current name of the group which should be renamednewName
- new name to give to the grouptrue
if and only if the group referenced by
oldName
existed, and was successfully renamed to newName
tables(), to see available tables
,
printTable(), to print a particular table to the terminal
,
table(), to get a particular table as a List
public Optional<List<String>> groups()
List
of all unique group names in the current
user's GROUPS
table, wrapped in an Optional
.
Returns an empty Optional
if there is a problem
getting the name of the current user.
List
of all unique group names in the current user's
GROUPS
table, wrapped in an Optional
, or if there was a
problem, an empty Optional
.public Optional<List<String>> users()
Optional<List<String>>
containing
the names of all users in the database.
Can only be executed by the database owner()
. If run by any other
user, an empty Optional
will be returned, and a
warning will be printed to the console. All usernames are returned in
all-uppercase letters.
Returns an empty List
wrapped in an Optional
and prints
an SQLException
to the console if there was a problem accessing
the database
.
Optional<List<String>>
containing
the names of all users in the databasepublic boolean addUser(String username, String password, String dboPassword)
username
and password
.
This method can only be run by the database owner (DBO), and, as an
added measure of security, it requires the DBO to re-enter their password
(dboPassword
).
Returns true
if the user was successfully added to the
database. If either the username
or password
provided
is null, returns false
.
Returns false
and prints an SQLException
to the console
if there was a problem accessing the database
.
username
- new user's usernamepassword
- new user's passworddboPassword
- password of the database ownertrue
if the new user was successfully added to the
database, false otherwisepublic boolean deleteUser(String username, String dboPassword)
username
from the
database, along with all of their data.
This method can only be run by the database owner (DBO), and, as an
added measure of security, it requires the DBO to re-enter their password
(dboPassword
).
Returns true
if the user was successfully removed from the
database. Returns false
if the user doesn't exist, if there was
some problem accessing the database, or if the database owner's password
(dboPassword
) is incorrect.
username
- username of the user to deletedboPassword
- password of the database ownertrue
if the user was successfully removed from the
database, false otherwisepublic boolean changePassword(String oldPassword, String newPassword)
If the user enters a null
, empty, or all-whitespace password,
this method prints an error and returns false
. Also, if
newPassword
has any leading or trailing whitespace, an error is
printed and false
is returned.
If the user enters an incorrect oldPassword
, the password is
not changed and false
is returned.
oldPassword
- this user's current passwordnewPassword
- new password for this usernewPassword
public boolean resetPassword(String username, String newPassword, String dboPassword)
username
to
newPassword
, provided that the current user is the DBO.
An error will be printed and false
will be returned from this
method if any of the following are true:
null
, empty, or all whitespacenewPassword
has any leading or trailing whitespaceusername
references a user that doesn't existdboPassword
) was entered incorrectly...otherwise, the specified user's password will be changed to
newPassword
and true
will be returned.
username
- user whose password should be resetnewPassword
- user's password will be set to this new passworddboPassword
- password of the database ownertrue
if and only if the specified user's password was
successfully changed to the newPassword
protected boolean verifyPassword(String username, String password)
true
if and only if the provided username
exists
in the database, and the provided password
matches that user's
password.
Returns false
if the user does not exist, if the password could
not be verified, or if an SQLException
was thrown.
username
- name of a user in the databasepassword
- that user's passwordtrue
if and only if the provided username
exists
in the database, and the provided password
matches that user's
passwordpublic List<String> tables()
List
containing the names of all user-created tables in
the database
accessible by the current user.
Returns an empty List
and prints an SQLException
to the
console if there was a problem accessing the database
. If there
are no user-created tables, this method returns an empty List
.
The database owner can access all tables in the database, but other users
can only access tables in their schema.
List
containing the names of all user-created tables in
the database
accessible by the current userpublic void printTable(String tableName, int columnWidth)
Regular users can print a table using its fully-qualified name (like
printTable("Bob.contacts")
) or its shortened table name (like
printTable("contacts")
), but the database owner must always use
fully-qualified names.
tableName
- name of table to printcolumnWidth
- printed width (in characters) of each columntables() to view tables available to the current user
,
table() to get a given table as a
public List<List<String>> table(String tableName)
List<List<String>>
, provided the
current user has permission to view that table.
If the table with name tableName
exists, this method will
return that table as a List
of List<String>
, where the
inner lists are the rows of the table and the String
s they hold
are the data in each column of the table. Rows are ordered top-to-bottom
and columns are ordered left-to-right, both with 0-indexing.
If the table has zero rows, its column headers will still be returned,
and if a table doesn't exist (or can't be accessed by the current user),
an empty List
will be returned.
tableName
- name of the table of interestList
of List<String>
rows, if the table exists and the user has permission to view itpublic Optional<String> user()
Optional
.
Returns an empty Optional
and prints an SQLException
to
the console if there was a problem accessing the database
.
Optional
public Optional<String> owner()
Optional
.
Returns an empty Optional
and prints an SQLException
to
the console if there was a problem accessing the database
.
Optional
.public boolean userIsDBO()
true
if and only if the current user is the database owner.
Returns false
if there was a problem getting the name of the
database owner or the current user, or if the current user is not the
database owner.
true
if and only if the current user is the database ownerCopyright © 2018–2019 IBAT. All rights reserved.