String[] removeHostIds = null; if (session.isRoot()) { oldHostIds = db.getHostIds(); removeHostIds = new String[removeReplicationEndpoints]; String[] newHostIds = new String[oldHostIds.length - removeReplicationEndpoints]; System.arraycopy(oldHostIds, removeReplicationEndpoints, newHostIds, 0, newHostIds.length); db.getParameters().put("hostIds", StringUtils.arrayCombine(newHostIds, ',')); db.getParameters().put("removeHostIds", StringUtils.arrayCombine(removeHostIds, ',')); Map<String, String> parameters = db.getParameters(); if (parameters != null && parameters.containsKey("removeHostIds")) { removeHostIds = StringUtils.arraySplit(parameters.get("removeHostIds"), ',', true); LealoneDatabase lealoneDB = LealoneDatabase.getInstance(); lealoneDB.removeDatabaseObject(session, db); db.setDeleteFilesOnDisconnect(true); if (db.getSessionCount() == 0) { db.drop(); Database newDB = new Database(db.getId(), db.getShortName(), parameters); newDB.setReplicationProperties(replicationProperties); newDB.setRunMode(runMode); lealoneDB.addDatabaseObject(session, newDB); newDB.notifyRunModeChanged();
@Override public int update() { session.getUser().checkSchemaAdmin(); Database db = session.getDatabase(); synchronized (db.getLock(DbObjectType.SCHEMA)) { User user = db.getUser(authorization); // during DB startup, the Right/Role records have not yet been loaded if (!db.isStarting()) { user.checkSchemaAdmin(); } if (db.findSchema(schemaName) != null) { if (ifNotExists) { return 0; } throw DbException.get(ErrorCode.SCHEMA_ALREADY_EXISTS_1, schemaName); } int id = getObjectId(); Schema schema = new Schema(db, id, schemaName, user, false); db.addDatabaseObject(session, schema); } return 0; }
synchronized User createAdminUser(String userName, byte[] userPasswordHash) { User user = new User(this, allocateObjectId(), userName, false); user.setAdmin(true); user.setUserPasswordHash(userPasswordHash); lockMeta(systemSession); addDatabaseObject(systemSession, user); systemSession.commit(); return user; }
/** * Immediately close the database. */ public void shutdownImmediately() { setPowerOffCount(1); try { checkPowerOff(); } catch (DbException e) { // ignore } for (Storage s : getStorages()) { s.closeImmediately(); } }
@Override public void close() { if (!closed) { try { database.checkPowerOff(); cleanTempTables(true); database.removeSession(this); } finally { closed = true; } } }
case EQUAL: case EQUAL_NULL_SAFE: result = database.areEqual(l, r); break; case NOT_EQUAL: case NOT_EQUAL_NULL_SAFE: result = !database.areEqual(l, r); break; case BIGGER_EQUAL: result = database.compare(l, r) >= 0; break; case BIGGER: result = database.compare(l, r) > 0; break; case SMALLER_EQUAL: result = database.compare(l, r) <= 0; break; case SMALLER: result = database.compare(l, r) < 0; break; default:
object = db.getSchema(schemaName).getConstant(objectName); break; case CONSTRAINT: object = db.getSchema(schemaName).getConstraint(objectName); break; case FUNCTION_ALIAS: object = db.getSchema(schemaName).findFunction(objectName); errorCode = ErrorCode.FUNCTION_ALIAS_NOT_FOUND_1; break; case INDEX: object = db.getSchema(schemaName).getIndex(objectName); break; case ROLE: schemaName = null; object = db.findRole(objectName); errorCode = ErrorCode.ROLE_NOT_FOUND_1; break; case SCHEMA: schemaName = null; object = db.findSchema(objectName); errorCode = ErrorCode.SCHEMA_NOT_FOUND_1; break; case SEQUENCE: object = db.getSchema(schemaName).getSequence(objectName); break; case TABLE_OR_VIEW: object = db.getSchema(schemaName).getTableOrView(session, objectName); break; case TRIGGER:
newDB = new Database(id, dbName, parameters); newDB.setReplicationProperties(replicationProperties); newDB.setEndpointAssignmentProperties(endpointAssignmentProperties); newDB.setRunMode(runMode); if (!parameters.containsKey("hostIds")) { String[] hostIds = NetEndpointManagerHolder.get().assignEndpoints(newDB); if (hostIds != null && hostIds.length > 0) newDB.getParameters().put("hostIds", StringUtils.arrayCombine(hostIds, ',')); else newDB.getParameters().put("hostIds", ""); if (newDB.getHostIds().length <= 1) { newDB.setRunMode(RunMode.CLIENT_SERVER); newDB.setReplicationProperties(null); newDB.init(); newDB.createRootUserIfNotExists();
/** * Remove the object from the database. * * @param session the session * @param obj the object to remove */ public void removeDatabaseObject(ServerSession session, DbObject obj) { checkWritingAllowed(); String objName = obj.getName(); DbObjectType type = obj.getType(); synchronized (getLock(type)) { Map<String, DbObject> map = getMap(type); if (SysProperties.CHECK && !map.containsKey(objName)) { DbException.throwInternalError("not found: " + objName); } Comment comment = findComment(obj); // lockMeta(session); if (comment != null) { removeDatabaseObject(session, comment); } int id = obj.getId(); obj.removeChildrenAndResources(session); map.remove(objName); removeMeta(session, id); } }
public int update0() { Database db = session.getDatabase(); if (!db.isPersistent()) { data.persistIndexes = false; } else { db.addSchemaObject(session, table); db.checkPowerOff(); db.removeSchemaObject(session, table); throw e;
break; case LOG: if (database.getMode().logIsLogBase10) { result = ValueDouble.get(Math.log10(v0.getDouble())); } else { ValueTimestamp vt = ValueTimestamp.get(new Timestamp(now)); if (v0 != null) { Mode mode = database.getMode(); vt = (ValueTimestamp) vt.convertScale(mode.convertOnlyToSmallerScale, v0.getInt()); result = ValueString.get(database.getShortName()); break; case USER: break; case READONLY: result = ValueBoolean.get(database.isReadOnly()); break; case DATABASE_PATH: { String path = database.getDatabasePath(); result = path == null ? (Value) ValueNull.INSTANCE : ValueString.get(path); break; case CONVERT: { v0 = v0.convertTo(dataType); Mode mode = database.getMode(); v0 = v0.convertScale(mode.convertOnlyToSmallerScale, scale); v0 = v0.convertPrecision(getPrecision(), false);
checkWritingAllowed(); lockMeta(session); Comment comment = findComment(obj); if (comment != null) { removeDatabaseObject(session, comment); Table t = getDependentTable(obj, null); if (t != null) { obj.getSchema().add(obj); removeMeta(session, obj.getId());
@Override public int update() { session.getUser().checkAdmin(); Database db = session.getDatabase(); synchronized (db.getAuthLock()) { if (db.findUser(roleName) != null) { throw DbException.get(ErrorCode.USER_ALREADY_EXISTS_1, roleName); } if (db.findRole(roleName) != null) { if (ifNotExists) { return 0; } throw DbException.get(ErrorCode.ROLE_ALREADY_EXISTS_1, roleName); } int id = getObjectId(); Role role = new Role(db, id, roleName, false); db.addDatabaseObject(session, role); } return 0; }
private void addOrUpdateSetting(ServerSession session, String name, String s, int v) { Database database = session.getDatabase(); if (database.isReadOnly()) { return; } Setting setting = database.findSetting(name); boolean addNew = false; if (setting == null) { addNew = true; int id = getObjectId(); setting = new Setting(database, id, name); } if (s != null) { if (!addNew && setting.getStringValue().equals(s)) { return; } setting.setStringValue(s); } else { if (!addNew && setting.getIntValue() == v) { return; } setting.setIntValue(v); } if (addNew) { database.addDatabaseObject(session, setting); } else { database.updateMeta(session, setting); } }
openMetaTable(); Setting setting = new Setting(this, allocateObjectId(), name); setting.setIntValue(Constants.BUILD_ID); lockMeta(systemSession); addDatabaseObject(systemSession, setting); closeOpenFilesAndUnlock(false); throw DbException.convert(e);
ServerSession sysSession = db.getSystemSession(); try { if (view == null) { Schema schema = session.getDatabase().getSchema(session.getCurrentSchemaName()); sysSession.setCurrentSchema(schema); view = new TableView(getSchema(), id, viewName, querySQL, null, columnNames, sysSession, false); sysSession.setCurrentSchema(db.getSchema(Constants.SCHEMA_MAIN)); db.addSchemaObject(session, view); } else { db.updateMeta(session, view);
case SQLStatement.CHECKPOINT: session.getUser().checkAdmin(); session.getDatabase().checkpoint(); break; case SQLStatement.CHECKPOINT_SYNC: session.getUser().checkAdmin(); session.getDatabase().sync(); break; case SQLStatement.PREPARE_COMMIT: // 2PC语句已经废弃 case SQLStatement.SHUTDOWN_IMMEDIATELY: session.getUser().checkAdmin(); session.getDatabase().shutdownImmediately(); break; case SQLStatement.SHUTDOWN: session.commit(); if (type == SQLStatement.SHUTDOWN_COMPACT || type == SQLStatement.SHUTDOWN_DEFRAG) { session.getDatabase().setCompactMode(type); session.getDatabase().setCloseDelay(0); Database db = session.getDatabase(); for (ServerSession s : db.getSessions(false)) { synchronized (s) { s.rollback();
public synchronized Database createEmbeddedDatabase(String name, ConnectionInfo ci) { Database db = databases.get(name); if (db != null) return db; HashMap<String, String> parameters = new HashMap<>(); for (Entry<Object, Object> e : ci.getProperties().entrySet()) { parameters.put(e.getKey().toString(), e.getValue().toString()); } int id = INSTANCE.allocateObjectId(); db = new Database(id, name, parameters); db.setRunMode(RunMode.EMBEDDED); db.init(); String userName = ci.getUserName(); byte[] userPasswordHash = ci.getUserPasswordHash(); db.createAdminUser(userName, userPasswordHash); addDatabaseObject(getSystemSession(), db); getSystemSession().commit(); return db; }
checkWritingAllowed(); DbObjectType type = obj.getType(); synchronized (getLock(type)) { Map<String, DbObject> map = getMap(type); String oldName = obj.getName(); if (SysProperties.CHECK) { int id = obj.getId(); removeMeta(session, id); map.remove(oldName); obj.rename(newName); map.put(newName, obj); updateMetaAndFirstLevelChildren(session, obj);
/** * Add an object to the database. * * @param session the session * @param obj the object to add */ public void addDatabaseObject(ServerSession session, DbObject obj) { int id = obj.getId(); if (id > 0 && !starting) { checkWritingAllowed(); } DbObjectType type = obj.getType(); synchronized (getLock(type)) { Map<String, DbObject> map = getMap(type); String name = obj.getName(); if (SysProperties.CHECK && map.get(name) != null) { DbException.throwInternalError("object already exists"); } // lockMeta(session); addMeta(session, obj); map.put(name, obj); } }