Mycat 實現MongoDB的BETWEEN AND和多IN&NOT IN查詢

阿新 • • 發佈：2018-12-24

在實現過程中第一就是分析怎麼去實現，其次在mycat哪個部分實現。首先我們知道BETWEEN AND是一個區間值查詢，而IN 是一個多值且的關係，其實最終目的都是封裝為MongoDB支援的資料庫操作語句，如：db.getCollection('t_alarm_aggr_20170822').find({ "F_START_TIME" : { "$gte" : "2017-08-21 00:00:00" , "$lte" : "2017-08-23 23:55:00"} , "F_ID" : { "$in" : [5000000001064]}}); 這樣就實現了我們的需求了。

BETWEEN AND查詢

主要操作io.mycat.route.util.RouterUtil.java類：

	
	/**
	 * @throws SQLNonTransientException 
	 * 解析betweenSQL 
	 * @MethodName: parseSQLToChangeBetweenSql 
	 * @Description: 
	 * @param ctx
	 * @throws
	 */
	private static void parseSQLToChangeBetweenSql( DruidShardingParseInfo ctx) throws SQLNonTransientException{
	      if(ctx==null){
            return; // 沒有上下文:no route to find
        }
        String tempStr=new String(ctx.getSql().toString()).replaceAll(" ", "").toUpperCase().trim();
        String endSql="";
		if(tempStr.contains("NOTBETWEEN")){
			throw new IllegalArgumentException("Not support' WHERE $condition NOT BETWEEN $a AND $b ' sql statement :"+ctx.getSql());
		}else if(tempStr.contains("BETWEEN")){
			String sql=ctx.getSql().toUpperCase();
			String conditions=StringUtil.keepInnerSpaceStr(sql.substring(sql.indexOf("WHERE")+5, sql.length())); 
			String strs[] =conditions.split("AND");
			String conditionField="";
			String values[]=new String [2];
			int index=-1;
			for (int i = 0; i < strs.length; i++) {
				if(strs[i].contains("BETWEEN")){
					String temp=StringUtil.keepInnerSpaceStr(strs[i]);
					conditionField=temp.split(" ")[0];
					values[0]=temp.split(" ")[2]+" "+temp.split(" ")[3];
					values[1]=StringUtil.keepInnerSpaceStr(strs[i+1]);
					index=i;
					break;
				}
			}
			Date dates[]=new Date [2];
			for (int i = 0; i < values.length; i++) {
				try {
					dates[i]=DateUtil.parseDate(StringUtil.removeBackquote(values[i]), DateUtil.DEFAULT_DATE_PATTERN); 
				} catch (ParseException e) {
					throw new SQLNonTransientException("date time format must be:"+DateUtil.DEFAULT_DATE_PATTERN);
				}
			}
			StringBuffer changeSql=new StringBuffer();
			if(dates[0].getTime()<dates[1].getTime()){
				changeSql.append(conditionField+" >= "+values[0]).append(" AND ").append(conditionField+" <= "+values[1]);
			}else{
				changeSql.append(conditionField+" <= "+values[0]).append(" AND ").append(conditionField+" >= "+values[1]);
			}
			String newSql=StringUtil.keepInnerSpaceStr(ctx.getSql().substring(0,sql.indexOf("WHERE")+5));
			for (int i = 0; i < strs.length; i++) {
				if(i<index){
					newSql+=" "+strs[i]+" AND ";
				}else if(i==index){
					newSql+=" "+changeSql.toString();
				}else if(i>index+1){
					newSql+=" AND "+strs[i];
				}
			}
			ctx.setSql(newSql);
		}
	}

尋找路由呼叫：

       /**
	 * 多表路由
	 */
	public static RouteResultset tryRouteForTables(SchemaConfig schema, DruidShardingParseInfo ctx,
			RouteCalculateUnit routeUnit, RouteResultset rrs, boolean isSelect, LayerCachePool cachePool)
			throws SQLNonTransientException {
		
		List<String> tables = ctx.getTables();
		
		if(schema.isNoSharding()||(tables.size() >= 1&&isNoSharding(schema,tables.get(0)))) {
			if(Pattern.matches(".*_201\\d{5,5}", tables.get(0))){//支援分表, t_location_20170704這種表，刪除結尾的_20170704後再查詢路由
				TableConfig tc=schema.getTables().get( tables.get(0).substring(0,  tables.get(0).length()-9));
				return routeToSingleNode(rrs, tc.getDataNodes().get(0), ctx.getSql());
			}
			return routeToSingleNode(rrs, schema.getDataNode(), ctx.getSql());
		}
		
		// 處理BETWEEN AND 查詢
		SQLStatementParser parser = new MySqlStatementParser(ctx.getSql()); 
		SQLStatement statement = parser.parseStatement(); 
		if(statement instanceof SQLSelectStatement){
			// =======between and query to change SQL=======
			parseSQLToChangeBetweenSql(ctx);
			rrs.setStatement(ctx.getSql());
		}

		//只有一個表的
		if(tables.size() == 1) {
			return RouterUtil.tryRouteForOneTable(schema, ctx, routeUnit, tables.get(0), rrs, isSelect, cachePool);
		}

		Set<String> retNodesSet = new HashSet<String>();
		//每個表對應的路由對映
		Map<String,Set<String>> tablesRouteMap = new HashMap<String,Set<String>>();

		//分庫解析資訊不為空
		Map<String, Map<String, Set<ColumnRoutePair>>> tablesAndConditions = routeUnit.getTablesAndConditions();
		if(tablesAndConditions != null && tablesAndConditions.size() > 0) {
			//為分庫表找路由
			RouterUtil.findRouteWithcConditionsForTables(schema, rrs, tablesAndConditions, tablesRouteMap, ctx.getSql(), cachePool, isSelect);
			if(rrs.isFinishedRoute()) {
				return rrs;
			}
		}

		//為全域性表和單庫表找路由
		for(String tableName : tables) {
			TableConfig tableConfig = schema.getTables().get(tableName.toUpperCase());
			if(tableConfig==null && Pattern.matches(".*_201\\d{5,5}", tableName)){//支援分表, t_location_20170704這種表，支援結尾的_20170704後再查詢路由
				tableConfig=schema.getTables().get(tableName.substring(0, tableName.length()-9));
			}
			if(tableConfig == null) {
				String msg = "can't find table define in schema "+ tableName + " schema:" + schema.getName();
				LOGGER.warn(msg);
				throw new SQLNonTransientException(msg);
			}
			if(tableConfig.isGlobalTable()) {//全域性表
				if(tablesRouteMap.get(tableName) == null) {
					tablesRouteMap.put(tableName, new HashSet<String>());
				}
				tablesRouteMap.get(tableName).addAll(tableConfig.getDataNodes());
			} else if(tablesRouteMap.get(tableName) == null) { //餘下的表都是單庫表
				tablesRouteMap.put(tableName, new HashSet<String>());
				tablesRouteMap.get(tableName).addAll(tableConfig.getDataNodes());
			}
		}

		boolean isFirstAdd = true;
		for(Map.Entry<String, Set<String>> entry : tablesRouteMap.entrySet()) {
			if(entry.getValue() == null || entry.getValue().size() == 0) {
				throw new SQLNonTransientException("parent key can't find any valid datanode ");
			} else {
				if(isFirstAdd) {
					retNodesSet.addAll(entry.getValue());
					isFirstAdd = false;
				} else {
					retNodesSet.retainAll(entry.getValue());
					if(retNodesSet.size() == 0) {//兩個表的路由無交集
						String errMsg = "invalid route in sql, multi tables found but datanode has no intersection "
								+ " sql:" + ctx.getSql();
						LOGGER.warn(errMsg);
						throw new SQLNonTransientException(errMsg);
					}
				}
			}
		}

		if(retNodesSet != null && retNodesSet.size() > 0) {
			String tableName = tables.get(0);
			TableConfig tableConfig = schema.getTables().get(tableName.toUpperCase());
			if(tableConfig==null && Pattern.matches(".*_201\\d{5,5}", tableName)){//支援分表, t_location_20170704這種表，支援結尾的_20170704後再查詢路由
				tableConfig=schema.getTables().get(tableName.substring(0, tableName.length()-9));
			}
			if(tableConfig.isDistTable()){
				routeToDistTableNode(tableName,schema, rrs, ctx.getSql(), tablesAndConditions, cachePool, isSelect);
				return rrs;
			}
			
			if(retNodesSet.size() > 1 && isAllGlobalTable(ctx, schema)) {
				// mulit routes ,not cache route result
				if (isSelect) {
					rrs.setCacheAble(false);
					routeToSingleNode(rrs, retNodesSet.iterator().next(), ctx.getSql());
				}
				else {//delete 刪除全域性表的記錄
					routeToMultiNode(isSelect, rrs, retNodesSet, ctx.getSql(),true);
				}

			} else {
				routeToMultiNode(isSelect, rrs, retNodesSet, ctx.getSql());
			}

		}
		return rrs;

	}

關鍵呼叫：

		
		// 處理BETWEEN AND 查詢
		SQLStatementParser parser = new MySqlStatementParser(ctx.getSql()); 
		SQLStatement statement = parser.parseStatement(); 
		if(statement instanceof SQLSelectStatement){
			// =======between and query to change SQL=======
			parseSQLToChangeBetweenSql(ctx);
			rrs.setStatement(ctx.getSql());
		}

多個WHERE IN 查詢

支援多個IN查詢，主要操作io.mycat.backend.jdbc.mongodb.MongoSQLParser.java類：

	    
    /**
     * WHERE IN 查詢
     * @MethodName: parseWhereIn 
     * @Description: 
     * @param expr
     * @param query
     * @throws
     */
    private void parseWhereIn(SQLSelectStatement selectStmt,SQLExpr expr,DBObject query ){
        if(expr==null){
            return; // 沒有條件:no where conditions return this
        }
        String conditionStr=new String(expr.toString()).replaceAll(" ", "").toUpperCase().trim();
        if(conditionStr.contains("NOTIN(")){
            throw new IllegalArgumentException("Not support' WHERE $condition NOT IN ' sql statement");
        }else if(conditionStr.contains("IN(")){
            String sql=new String(selectStmt.getSelect().toString()).toUpperCase();
            String conditions=StringUtil.keepInnerSpaceStr(sql.substring(sql.lastIndexOf("WHERE")+5, sql.length())); 
            String manyIns[]=conditions.split("AND ");
            for (int a = 0; a < manyIns.length; a++) {
                if(manyIns[a].contains(" IN")){
                    String filedStr=StringUtil.keepInnerSpaceStr(manyIns[a].substring(0,manyIns[a].lastIndexOf("IN")));
                    String currentConditions=StringUtil.keepInnerSpaceStr(manyIns[a].substring(manyIns[a].lastIndexOf("(")+1, manyIns[a].lastIndexOf(")")));
                    String strs[]=filedStr.split(" ");
                    String field="";
                    for (int i = strs.length-1; i >=0 ; i++) {
                        if(!"".equals(strs[i].trim())){
                            field=strs[i].trim();
                            break;
                        }
                    }
                    String [] values=currentConditions.split(",");
                    BasicDBList blist=new BasicDBList();
                    for (int i = 0; i < values.length; i++) {
                        if(ValidateUtils.Number(values[i].trim())){
                            blist.add(Long.valueOf(values[i].trim()));
                        }else{
                            blist.add(values[i].trim());
                        }
                    }
                    BasicDBObject obj=new BasicDBObject();
                    obj.put("$in", blist);
                    query.put(field, obj);
                }
            }
        }
    }

支援NOT IN 查詢：

	
	/**
	 * WHERE IN 查詢
	 * @MethodName: parseWhereIn 
	 * @Description: 
	 * @param expr
	 * @param query
	 * @throws
	 */
	private void parseWhereIn(SQLSelectStatement selectStmt,SQLExpr expr,DBObject query ){
		if(expr==null){
			return; // 沒有條件:no where conditions return this
		}
		String conditionStr=new String(expr.toString()).replaceAll(" ", "").toUpperCase().trim();
		if(conditionStr.contains("IN(")||conditionStr.contains("NOTIN(")){
			String sql=new String(selectStmt.getSelect().toString()).toUpperCase();
			String conditions=StringUtil.keepInnerSpaceStr(sql.substring(sql.lastIndexOf("WHERE")+5, sql.length())); 
			String manyIns[]=conditions.split("AND");
			for (int a = 0; a < manyIns.length; a++) {
				String temp=new String(manyIns[a]).trim();
				if(temp.contains(" IN")&&!temp.contains("NOT IN")){
					String filedStr=StringUtil.keepInnerSpaceStr(manyIns[a].substring(0,manyIns[a].lastIndexOf(" IN")));
					String currentConditions=StringUtil.keepInnerSpaceStr(manyIns[a].substring(manyIns[a].lastIndexOf("(")+1, manyIns[a].lastIndexOf(")")));
					String strs[]=filedStr.split(" ");
					String field="";
					for (int i = strs.length-1; i >=0 ; i++) {
						if(!"".equals(strs[i].trim())){
							field=strs[i].trim();
							break;
						}
					}
					String [] values=currentConditions.split(",");
					BasicDBList blist=new BasicDBList();
					for (int i = 0; i < values.length; i++) {
						if(ValidateUtils.Number(values[i].trim())){
							blist.add(Long.valueOf(values[i].trim()));
						}else{
							blist.add(values[i].trim());
						}
					}
					BasicDBObject obj=new BasicDBObject();
					obj.put("$in", blist);
					query.put(field, obj);
				}else if(temp.contains(" IN")&&temp.contains("NOT IN")){
					String filedStr=StringUtil.keepInnerSpaceStr(manyIns[a].substring(0,manyIns[a].lastIndexOf("NOT IN")));
					String currentConditions=StringUtil.keepInnerSpaceStr(manyIns[a].substring(manyIns[a].lastIndexOf("(")+1, manyIns[a].lastIndexOf(")")));
					String strs[]=filedStr.split(" ");
					String field="";
					for (int i = strs.length-1; i >=0 ; i++) {
						if(!"".equals(strs[i].trim())){
							field=strs[i].trim();
							break;
						}
					}
					String [] values=currentConditions.split(",");
					BasicDBList blist=new BasicDBList();
					for (int i = 0; i < values.length; i++) {
						if(ValidateUtils.Number(values[i].trim())){
							blist.add(Long.valueOf(values[i].trim()));
						}else{
							blist.add(values[i].trim());
						}
					}
					BasicDBObject obj=new BasicDBObject();
					obj.put("$nin", blist);
					query.put(field, obj);
				}
			}
		}
	}

執行查詢呼叫：

       public MongoData query() throws MongoSQLException, SQLNonTransientException {
		if (!(statement instanceof SQLSelectStatement)) {
			// return null;
			throw new IllegalArgumentException("not a query sql statement");
		}
		MongoData mongo = new MongoData();
		DBCursor c = null;
		SQLSelectStatement selectStmt = (SQLSelectStatement) statement;
		SQLSelectQuery sqlSelectQuery = selectStmt.getSelect().getQuery();
		int icount = 0;
		if (sqlSelectQuery instanceof MySqlSelectQueryBlock) {
			MySqlSelectQueryBlock mysqlSelectQuery = (MySqlSelectQueryBlock) selectStmt.getSelect().getQuery();
			if (mysqlSelectQuery.getFrom() != null) {
				BasicDBObject fields = new BasicDBObject();
				// 顯示的欄位
				for (SQLSelectItem item : mysqlSelectQuery.getSelectList()) {
					// System.out.println(item.toString());
					if (!(item.getExpr() instanceof SQLAllColumnExpr)) {
						if (item.getExpr() instanceof SQLAggregateExpr) {
							SQLAggregateExpr expr = (SQLAggregateExpr) item.getExpr();
							if (expr.getMethodName().equals("COUNT")||expr.getMethodName().equals("SUM")) {
								icount = 1;
								mongo.setField(getExprFieldName(expr), Types.BIGINT);
							}
							fields.put(getExprFieldName(expr), Integer.valueOf(1));
						} else {
							fields.put(getFieldName(item), Integer.valueOf(1));
						}
					}

				}

				// 表名
				SQLTableSource table = mysqlSelectQuery.getFrom();
				DBCollection coll = this._db.getCollection(table.toString());
				mongo.setTable(table.toString());
				SQLExpr expr = mysqlSelectQuery.getWhere();
				DBObject query = parserWhere(expr);
				
				// parse where IN query 
				parseWhereIn(selectStmt, expr, query);
				// parse where IN query 
				
				SQLSelectGroupByClause groupby = mysqlSelectQuery.getGroupBy();
				BasicDBObject gbkey = new BasicDBObject();
				if (groupby != null) {
					for (SQLExpr gbexpr : groupby.getItems()) {
						if (gbexpr instanceof SQLIdentifierExpr) {
							String name = ((SQLIdentifierExpr) gbexpr).getName();
							gbkey.put(name, Integer.valueOf(1));
						}
					}
					icount = 2;
				}
				int limitoff = 0;
				int limitnum = 0;
				if (mysqlSelectQuery.getLimit() != null) {
					limitoff = getSQLExprToInt(mysqlSelectQuery.getLimit().getOffset());
					limitnum = getSQLExprToInt(mysqlSelectQuery.getLimit().getRowCount());
				}

				if (icount == 1) {
					/***********distinct***********/
					if(selectStmt.getSelect().toString().toLowerCase().contains("distinct")){
						DBCursor cursor=coll.find(query);
						Map<String,DBObject> distinctMap=new HashMap<String,DBObject>();
						for (DBObject dbObject : cursor) {
							String key=dbObject.toString().hashCode()+"";
							if(!distinctMap.containsKey(key)){
								distinctMap.put(key, dbObject);
							}
						}
						mongo.setCount(distinctMap.size());
					}else{
						mongo.setCount(coll.count(query));
					}
					/***********distinct***********/
					mongo.setAggrResult(true);
				} else if (icount == 2) {
					BasicDBObject initial = new BasicDBObject();
					initial.put("num", 0);
					String reduce = "function (obj, prev) { " + "  prev.num++}";
					mongo.setGrouyBy(coll.group(gbkey, query, initial, reduce));
				} else {
					if ((limitoff > 0) || (limitnum > 0)) {
						c = coll.find(query, fields).skip(limitoff).limit(limitnum);
					} else {
						c = coll.find(query, fields);
					}
					SQLOrderBy orderby = mysqlSelectQuery.getOrderBy();
					if (orderby != null) {
						BasicDBObject order = new BasicDBObject();
						for (int i = 0; i < orderby.getItems().size(); i++) {
							SQLSelectOrderByItem orderitem = orderby.getItems().get(i);
							order.put(orderitem.getExpr().toString(),
									Integer.valueOf(getSQLExprToAsc(orderitem.getType())));
						}
						c.sort(order);
						// System.out.println(order);
					}
				}
				mongo.setCursor(c);
			} else {
				mongo = query2();
			}

		}
		return mongo;
	}

核心呼叫：

				// 表名
				SQLTableSource table = mysqlSelectQuery.getFrom();
				DBCollection coll = this._db.getCollection(table.toString());
				mongo.setTable(table.toString());
				SQLExpr expr = mysqlSelectQuery.getWhere();
				DBObject query = parserWhere(expr);
				
				// parse where IN query 
				parseWhereIn(selectStmt, expr, query);
				// parse where IN query

實現分段查詢原理

看完下面的內容就明白了：

db.getCollection('t_alarm_aggr_20170822').find({});

db.getCollection('t_alarm_aggr_20170822').find({ "F_START_TIME" : { "$gte" : "2017-08-21 00:00:00" , "$lte" : "2017-08-23 23:55:00"}});

db.getCollection('t_alarm_aggr_20170822').find({ "F_START_TIME" : { "$gte" : "2017-08-21 00:00:00" , "$lte" : "2017-08-23 23:55:00"} , "F_ID" : { "$in" : [5000000001063,5000000001064]}}).sort({"F_START_TIME":-1,"F_ALARM_ID":-1});

注：實際上只要滿足mongodb的shell命令就可以了。

測試驗證修改效果

BETWEEN AND:

mysql> SELECT F_ID, F_VEHICLE_ID, F_ALARMBAK, F_START_TIME, F_START_ID, F_END_TIME, F_STATUS, F_DSpeed, F_Speed, F_ALARM_ID, F_ENTERPRISE_ID FROM T_ALARM_AGGR WHERE F_START_TIME BETWEEN '2017-08-21 00:00:00' AND  '2017-08-23 23:55:00';
ERROR 2006 (HY000): MySQL server has gone away
No connection. Trying to reconnect...
Connection id:    108
Current database: cvnavidb

+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
| F_ID          | F_VEHICLE_ID     | F_ALARMBAK | F_START_TIME        | F_START_ID    | F_END_TIME          | F_STATUS | F_DSpeed | F_Speed | F_ALARM_ID | F_ENTERPRISE_ID |
+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-21 00:26:00 | 5000000468156 | 2017-08-21 00:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-21 00:26:01 | 5000000468160 | 2017-08-21 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-21 10:26:00 | 5000000468156 | 2017-08-21 10:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-22 00:26:00 | 5000000468156 | 2017-08-22 00:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-22 00:26:01 | 5000000468160 | 2017-08-22 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-22 10:26:00 | 5000000468156 | 2017-08-22 10:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-23 00:26:00 | 5000000468156 | 2017-08-23 00:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-23 00:26:01 | 5000000830671 | 2017-08-23 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
8 rows in set (0.25 sec)

mysql>

WHERE IN:

mysql> SELECT F_ID, F_VEHICLE_ID, F_ALARMBAK, F_START_TIME, F_START_ID, F_END_TIME, F_STATUS, F_DSpeed, F_Speed, F_ALARM_ID, F_ENTERPRISE_ID FROM T_ALARM_AGGR WHERE F_START_TIME >= '2017-08-21 00:00:00' AND  F_START_TIME<='2017-08-23 23:55:00'  AND F_ID IN (5000000001064);
+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
| F_ID          | F_VEHICLE_ID     | F_ALARMBAK | F_START_TIME        | F_START_ID    | F_END_TIME          | F_STATUS | F_DSpeed | F_Speed | F_ALARM_ID | F_ENTERPRISE_ID |
+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-22 00:26:01 | 5000000468160 | 2017-08-22 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-21 00:26:01 | 5000000468160 | 2017-08-21 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-23 00:26:01 | 5000000830671 | 2017-08-23 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
3 rows in set (0.00 sec)

mysql> SELECT F_ID, F_VEHICLE_ID, F_ALARMBAK, F_START_TIME, F_START_ID, F_END_TIME, F_STATUS, F_DSpeed, F_Speed, F_ALARM_ID, F_ENTERPRISE_ID FROM T_ALARM_AGGR WHERE F_START_TIME >= '2017-08-21 00:00:00' AND  F_START_TIME<='2017-08-23 23:55:00'  AND F_ID IN (50000000010613,5000000001064);
+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
| F_ID          | F_VEHICLE_ID     | F_ALARMBAK | F_START_TIME        | F_START_ID    | F_END_TIME          | F_STATUS | F_DSpeed | F_Speed | F_ALARM_ID | F_ENTERPRISE_ID |
+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-23 00:26:00 | 5000000468156 | 2017-08-23 00:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-23 00:26:01 | 5000000830671 | 2017-08-23 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-22 00:26:00 | 5000000468156 | 2017-08-22 00:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-22 00:26:01 | 5000000468160 | 2017-08-22 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-21 00:26:00 | 5000000468156 | 2017-08-21 00:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-22 10:26:00 | 5000000468156 | 2017-08-22 10:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
| 5000000001064 | 4908520417546251 | NULL       | 2017-08-21 00:26:01 | 5000000468160 | 2017-08-21 00:26:01 |        0 | NULL     | NULL    |         49 | NULL            |
| 5000000001063 | 4908520417546251 | NULL       | 2017-08-21 10:26:00 | 5000000468156 | 2017-08-21 10:26:00 |        0 | NULL     | NULL    |         48 | NULL            |
+---------------+------------------+------------+---------------------+---------------+---------------------+----------+----------+---------+------------+-----------------+
8 rows in set (0.01 sec)

多個WHERE IN:

注：上面的測試注意驗證功能實現，實際開發中肯定有問題需要做更細緻的調整。

修改過原始碼後打包請備份jar包到其他路徑並刪除原來的jar在進行上傳！下圖是因為沒有刪除導致修改程式包不起作用：

Mycat 實現MongoDB的BETWEEN AND和多IN&NOT IN查詢

在實現過程中第一就是分析怎麼去實現，其次在mycat哪個部分實現。首先我們知道BETWEEN AND是一個區間值查詢，而IN 是一個多值且的關係，其實最終目的都是封裝為MongoDB支援的資料庫操作語句，如：db.getCollection('t_alarm_aggr_201

IN,NOT IN,ANY和ALL用於比較子查詢返回多行資料時你不知道的陷阱

本文簡單講述一下在使用IN,NOT IN,ANY,ALL等對從子查詢中返回的資料做比較的時候一不小心就會犯的錯誤. 測試的的資料如下:TEST表中有3條資料,其中id為3的行name的值為null. ID Name 1 name1 2 name2 3 1,IN在子查

python3.6入門到高階(全棧) day29 socketserver實現服務端和多個客戶端通訊

　什麼是socketserver? 　　　　TCP協議下的socket實現了服務端一次只能和一個客戶端進行通訊, 而socketserver實現了服務端一次能和多個客戶端進行通訊, 底層呼叫的還是socket. import socketserver class MyServer(so

Java Servlet3.0使用getPart/getParts實現單檔案和多檔案上傳

一、使用工具：（1）Firefox瀏覽器（2）Eclipse 二、實現單檔案上傳（1）Servlet 原始碼 package com.servlet; import java.io.IOExce

我在用mycat實現web專案的多租戶（一）

還沒畢業的小菜雞，在實習，領導讓做多租戶，於是聽說了mycat。首先先去百度了Mycat。(指路官網：http://www.mycat.io/) 很開心的發現有官方文件（Mycat權威指南），還是我能看得懂的中文，真開心。我有pdf的，想要的私信我。快300頁的文件，我只看了前

IN和EXISTS、not in 和not exists的效率詳解

從效率來看： 1) select * from T1 where exists(select 1 from T2 where T1.a=T2.a) ; T1資料量小而T2資料量非常大時，T1<<T2 時，1) 的查詢效率高。 2) select * from T1 wher

C語言實現C++繼承和多型

C++中的多型我們知道的是在C++中會維護一張虛擬函式表，根據賦值相容規則，我們知道父類的指標或者引用是可以指向子類物件的。如果一個父類的指標或者引用呼叫父類的虛擬函式則該父類的指標會在自己的虛擬函式表中查詢自己的函式地址，如果該父類物件的指標或者引用指向的是子類的物件，而且該子類已經重寫了父

模擬繼承和多型--C語言模式實現C++繼承和多型

C語言與C++語言的不同？ C語言是面向過程的語言。 C++語言是面向物件的語言。面向過程：面向過程就是分析出解決問題所需要的步驟，然後用函式把這些步驟一步一步實現，使用的時候一個一個依次呼叫就可以了。面向物件：面向物件是把構成問題事務分解成各個物件

css實現單行文字和多行文字省略號

單行文字出現省略號的條件： <style> p { width: 200px; /*寬度*/ text-overflow: ellipsis; /*文字以省略號的方式隱藏*/ white-space: nowrap;/*禁止文字內容折行*/

遍歷資料庫表（ACCESS/SQL SERVER）的方法。SQL中IN,NOT IN,EXISTS,NOT EXISTS的用法和差別。資料庫中的exists與in

遍歷資料庫表（ACCESS/SQL SERVER）的方法以前在網上查詢遍歷SQL資料庫表的方法，可以用 select name from sysobjects where xtype='u' and (not name LIKE 'dtproperties') 來查詢SQL的系

使用Ajaxfileupload外掛分別實現單檔案和多檔案上傳

一．Ajaxfileupload上傳檔案首先頁面jsp程式碼：需要引入jquery和ajaxfileupload.js <head> <meta http-equiv="Content-Type" content="text/html; charset

群聊實現（tcp和多執行緒）

服務端程式碼 package com.cyj.tcp.chat2; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import ja

hadoop實現單表和多表關聯

補充一個單錶鏈接的例子： ublic class Single { private static class SingleMapper extends Mapper<LongWritable, Text, Text,

mybatis sql in not in的使用

col item select lis log div ots sel index xml配置 <select id="SelectAllByNotsampleNo" resultMap="BaseResultMap" parameterType="java.l

Oracle，用left join 替代 exists ,not exists,in , not in，提高效率

.cn rom mage png 高效 pan div sele bsp Not IN問題 Exists，not Exists，in，not in 例如： DELETE FROM YSHA WHERE NOT EXISTS(SELECT 1 FROM YSHB B

in,not in,整體註釋

name = "鄭建文" if '建' in name: print('在') else: print('error') if '文' not in name: print('不在') else: print('error') 輸出: 在 error

為什麼 EXISTS(NOT EXIST) 與 JOIN(LEFT JOIN) 的效能會比 IN(NOT IN) 好

前言網路上有大量的資料提及將 IN 改成 JOIN 或者 exist，然後修改完成之後確實變快了，可是為什麼會變快呢？IN、EXIST、JOIN 在 MySQL 中的實現邏輯如何理解呢？本文也是比較粗淺的做一些介紹，知道了 MySQL 的大概執行邏輯，也方便理解。本書絕大多數內容來自：高效能MySQL第三版

oralce中exists not exists in not in對於NULL的處理

1. 先討論 in 與 not in中存在NULL的情況, sql語句如下：複製程式碼 1 select 1 result1 from dual where 1 not in (2, 3); 2 3 4 select

Elasticsearch 查詢in 和 not in 的實現方式

最近用到ES查詢，因用的是Java寫的，需要實現一個需求：過濾一部分id，查詢時不需要查出來。既然需要不包含，那麼首先需要實現包含的方式（精確完全匹配），這裡我們要用到的是termQuery首先看下ES Bool聯合查詢的屬性：bool聯合查詢: must,shoul

hive例項講解實現in和not in子句

目前hive不支援 in或not in 中包含查詢子句的語法，所以只能通過left join實現。假設有一個登陸表login(當天登陸記錄,只有一個uid),和一個使用者登錄檔regusers(當天註冊使用者，欄位只有一個uid)，這兩個表都包含一個欄位,uid。

Mycat 實現MongoDB的BETWEEN AND和多IN&NOT IN查詢

BETWEEN AND查詢

多個WHERE IN 查詢

實現分段查詢原理

測試驗證修改效果

相關推薦