前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到教程。

 

1. 报错：

### Cause: java.sql.SQLSyntaxErrorException: ORA-00911: 无效字符

; bad SQL grammar []; nested exception is java.sql.SQLSyntaxErrorException: ORA-00911: 无效字符



2.出错 原因：

1)  sql在数据库执行都是OK的。  

真正的原因是： 在mybatis 中sql结尾处多了一个" ; " 去掉就可以了。

2)  mybatis ，我查出的数据在resultMap中没有对应的映射字段来匹配，查到的结果无法全部填充到对象属性才报错的。

即：

  SELECT 
              DISTINCT allData.time AS CREATE_DATE,         
              allData.FORMAT AS FORMAT,           
              allData.ORDER_TYPE  AS ORDER_TYPE,
              allData.ORDER_TYPE_DEC  AS ORDER_TYPE_DEC,
              allData.ACCOUNT  AS ACCOUNT....

中FORMAT 对应的 <result property="format" column="FORMAT" jdbcType="INTEGER" />  忘了写了。

 

ElasticSearch Version:6.2.2

Nested Aggregation

A special single bucket aggregation that enables aggregating nested documents.

一种特殊的单桶聚合，可聚合嵌套文档。
Reverse nested Aggregation

A special single bucket aggregation that enables aggregating on parent docs from nested documents. Effectively this aggregation can break out of the nested block structure and link to other nested structures or the root document, which allows nesting other aggregations that aren’t part of the nested object in a nested aggregation.
The reverse_nested aggregation must be defined inside a nested

aggregation.

一种特殊的单桶聚合，支持从嵌套文档中聚合父文档。实际上，这种聚合可以脱离嵌套块结构，并链接到其他嵌套结构或根文档，这允许嵌套不属于嵌套聚合中嵌套对象的其他聚合。reverse_nested聚合必须在嵌套聚合中定义。

DSL:

{
	"size": 0,
	"query": {
		"bool": {
			"filter": [{
				"term": {
					"params1": {
						"value": 0,
						"boost": 1.0
					}
				}
			}, {
				"nested": {
					"query": {
						"bool": {
							"filter": [{
								"bool": {
									"should": [{
										"bool": {
											"filter": [{
												"term": {
													"nestedObject.params2": {
														"value": 0,
														"boost": 1.0
													}
												}
											}],
											"adjust_pure_negative": true,
											"boost": 1.0
										}
									}, {
										"bool": {
											"should": [{
												"bool": {
													"filter": [{
														"term": {
															"nestedObject.params2": {
																"value": "1",
																"boost": 1.0
															}
														}
													}, {
														"range": {
															"nestedObject.params2Start": {
																"from": null,
																"to": "07:02:26",
																"include_lower": true,
																"include_upper": true,
																"boost": 1.0
															}
														}
													}],
													"adjust_pure_negative": true,
													"boost": 1.0
												}
											}, {
												"bool": {
													"filter": [{
														"term": {
															"nestedObject.params2": {
																"value": 1,
																"boost": 1.0
															}
														}
													}, {
														"range": {
															"nestedObject.params2End": {
																"from": "07:02:26",
																"to": null,
																"include_lower": true,
																"include_upper": true,
																"boost": 1.0
															}
														}
													}],
													"adjust_pure_negative": true,
													"boost": 1.0
												}
											}, {
												"bool": {
													"filter": [{
														"term": {
															"nestedObject.params2": {
																"value": 1,
																"boost": 1.0
															}
														}
													}, {
														"range": {
															"nestedObject.params2Start": {
																"from": null,
																"to": "07:02:26",
																"include_lower": true,
																"include_upper": true,
																"boost": 1.0
															}
														}
													}, {
														"range": {
															"nestedObject.params2End": {
																"from": "07:02:26",
																"to": null,
																"include_lower": true,
																"include_upper": true,
																"boost": 1.0
															}
														}
													}],
													"adjust_pure_negative": true,
													"boost": 1.0
												}
											}],
											"adjust_pure_negative": true,
											"boost": 1.0
										}
									}],
									"adjust_pure_negative": true,
									"boost": 1.0
								}
							}, {
								"bool": {
									"should": [{
										"bool": {
											"filter": [{
												"range": {
													"nestedObject.params3": {
														"from": "2020-05-07 07:02:26",
														"to": null,
														"include_lower": true,
														"include_upper": true,
														"boost": 1.0
													}
												}
											}, {
												"range": {
													"nestedObject.params4": {
														"from": null,
														"to": "2020-05-07 07:02:26",
														"include_lower": true,
														"include_upper": true,
														"boost": 1.0
													}
												}
											}, {
												"term": {
													"nestedObject.params5": {
														"value": 4,
														"boost": 1.0
													}
												}
											}],
											"adjust_pure_negative": true,
											"boost": 1.0
										}
									}, {
										"bool": {
											"should": [{
												"term": {
													"nestedObject.params5": {
														"value": 1,
														"boost": 1.0
													}
												}
											}, {
												"term": {
													"nestedObject.params5": {
														"value": 2,
														"boost": 1.0
													}
												}
											}],
											"adjust_pure_negative": true,
											"boost": 1.0
										}
									}],
									"adjust_pure_negative": true,
									"boost": 1.0
								}
							}],
							"should": [{
								"term": {
									"nestedObject.params6": {
										"value": 0,
										"boost": 1.0
									}
								}
							}, {
								"term": {
									"nestedObject.params6": {
										"value": 1,
										"boost": 1.0
									}
								}
							}, {
								"term": {
									"nestedObject.params6": {
										"value": 4,
										"boost": 1.0
									}
								}
							}],
							"adjust_pure_negative": true,
							"boost": 1.0
						}
					},
					"path": "nestedObject",
					"ignore_unmapped": false,
					"score_mode": "none",
					"boost": 1.0
				}
			}, {
				"term": {
					"params7": {
						"value": "CN"
					}
				}
			}],
			"adjust_pure_negative": true,
			"boost": 1.0
		}
	},
	"_source": true,
	"aggregations": {
		"params7": {
			"terms": {
				"field": "params7",
				"missing": "",
				"size": 10000,
				"min_doc_count": 1,
				"shard_min_doc_count": 0,
				"show_term_doc_count_error": false,
				"order": [{
					"_count": "desc"
				}, {
					"_key": "asc"
				}],
				"collect_mode": "breadth_first"
			},
			"aggregations": {
				"params8": {
					"nested": {
						"path": "nestedObject"
					},
					"aggregations": {
						"packageType": {
							"terms": {
								"field": "nestedObject.params8"
							},
							"aggregations": {
								"params5": {
									"filter": {
										"term": {
											"nestedObject.params5": {
												"value": 1,
												"boost": 1.0
											}
										}
									},
									"aggregations": {
										"params5sum": {
											"sum": {
												"field": "nestedObject.params5"
											}
										}
									}

								},
								"params9": {
									"reverse_nested": {},
									"aggregations": {
										"params9-1": {
											"filter": {
												"term": {
													"params1": {
														"value": 0,
														"boost": 1.0
													}
												}
											}
										}
									}

								},
								"params2": {
									"filter": {
										"nested": {
											"query": {
												"term": {
													"nestedObject.params2": {
														"value": 1,
														"boost": 1.0
													}
												}
											},
											"path": "nestedObject",
											"ignore_unmapped": false,
											"score_mode": "none",
											"boost": 1.0
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}
}

欢迎大家关注我的公众号，添加我为好友！



springBoot项目遇到了“Handler dispatch failed; nested exception is java.lang.StackOverflowError”的错误。

总结一哈：

StackOverflowError通常情况下是死循环或者是循环依赖了。

Caused by: java.lang.StackOverflowError
	at com.hry.seckill.service.impl.GoodsServiceImpl.getGoodsVoList(GoodsServiceImpl.java:17)
	at com.hry.seckill.service.impl.GoodsServiceImpl.getGoodsVoList(GoodsServiceImpl.java:17)
	at com.hry.seckill.service.impl.GoodsServiceImpl.getGoodsVoList(GoodsServiceImpl.java:17)
	at com.hry.seckill.service.impl.GoodsServiceImpl.getGoodsVoList(GoodsServiceImpl.java:17)
	at com.hry.seckill.service.impl.GoodsServiceImpl.getGoodsVoList(GoodsServiceImpl.java:17)
	at com.hry.seckill.service.impl.GoodsServiceImpl.getGoodsVoList(GoodsServiceImpl.java:17)

 

然后检查定位到的位置，发现错误：

 

 

@Service
public class GoodsServiceImpl implements GoodsService {
    @Autowired
    private GoodsService goodsService;

我在Service中没有正确引用编写的Mapper而是引用了Service，所以报错，改正即可。

 

@Service
public class GoodsServiceImpl implements GoodsService {
    @Autowired
    private GoodsMapper goodsMapper;

最后重启项目即可。

欢迎大家关注我的公众号，添加我为好友！

题目描述

Dilworth is the world’s most prominent collector of Russian nested dolls: he literally has thousands of them! You know, the wooden hollow dolls of different sizes of which the smallest doll is contained in the second smallest,
 and this doll is in turn contained in the next one and so forth. One day he wonders if there is another way of nesting them so he will end up with fewer nested dolls? After all, that would make his collection even more magnificent! He unpacks each nested doll
 and measures the width and height of each contained doll. A doll with width w1 and height h1 will fit in another doll of width w2 and height h2 if and only if w1 < w2 and h1 < h2. Can you help him calculate the smallest number of nested dolls possible to assemble
 from his massive list of measurements? 

输入描述:
On the first line of input is a single positive integer 1 <= t <= 20 specifying the number of test cases to follow. Each test case begins with a positive integer 1 <= m <= 20000 on a line of itself telling the number of dolls in the test case. Next follow 2m positive integers w1, h1,w2, h2, . . . ,wm, hm, where wi is the width and hi is the height of doll number i. 1 <= wi, hi <= 10000 for all i.
       

输出描述:
For each test case there should be one line of output containing the minimum number of nested dolls possible.
       


示例1


输入

4
3
20 30 40 50 30 40
4
20 30 10 10 30 20 40 50
3
10 30 20 20 30 10
4
10 10 20 30 40 50 39 51



输出

1
2
3
2

#include <iostream>
#include <cstring>
using namespace std;
 
struct node
{
    int x, y;
};
int cmp (const void *a, const void *b)
{
    node *c = (node *)a;
    node *d = (node *)b;
    if (c -> x != d -> x)
        return c -> x - d -> x;
    else
        return d -> y - c -> y;
}
 
int main ()
{
    node stu[21000];
    int t, n, i, j, k, a[21000];
 
    cin >> t;
 
    while (t--)
    {
        memset (a, 0, sizeof(a));
 
        cin >> n;
 
        for (i=0; i<n; i++)
            cin >> stu[i].x >> stu[i].y;
 
        qsort (stu, n, sizeof (stu[0]), cmp);
 
        a[0] = stu[0].y, k = 1;
        for (i=1; i<n; i++)
        {
            for (j=0; j<k; j++)
            {
                if (a[j] < stu[i].y)
                {
                    a[j] = stu[i].y;
                    break;
                }
            }
            if (j == k)
                a[k++] = stu[i].y;
        }
        cout << k << endl;
    }
    return 0;
}