在本文中，我们将给您介绍关于查找表中每个ID的最大连续年份的详细内容，并且为您解答OracleSQL的相关问题，此外，我们还将为您提供关于AccessSQL查询：查找表中每个不同条目的最新日期的行、c
在本文中，我们将给您介绍关于查找表中每个ID的最大连续年份的详细内容，并且为您解答Oracle SQL的相关问题，此外，我们还将为您提供关于Access SQL查询：查找表中每个不同条目的最新日期的行、c# – 如何使用LINQ查找词典列表中每个键的最大值？、dapper之连接数据库（Oracle，SQL Server，MySql）、Django 数据库连接配置（Oracle、Mysql）的知识。
本文目录一览：- 查找表中每个ID的最大连续年份（Oracle SQL）（查询表中最大的id）
- Access SQL查询：查找表中每个不同条目的最新日期的行
- c# – 如何使用LINQ查找词典列表中每个键的最大值？
- dapper之连接数据库（Oracle，SQL Server，MySql）
- Django 数据库连接配置（Oracle、Mysql）
查找表中每个ID的最大连续年份（Oracle SQL）（查询表中最大的id）
我正在尝试解决一个问题，该问题是如何在一系列记录中查找连续年份的最大数量。在以下示例中：
身份证年1 1993年1994年1月1日1995年1月1日1995年1月1日1 20011 20021993年2月2日1995年2月2日1996年2月2日1996年2月2日1998年2月2日1999年2月2日2 20002001年2月2日2001年2月2日我的结果集应该看起来像
身份证数1 32 4我必须用oracle SQL编写代码。
答案1
小编典典这将产生您想要的结果：
select id, ayear, byear, yeardifffrom( select a.id, a.year ayear, b.year byear, (b.year - a.year)+1 yeardiff, dense_rank() over (partition by a.id order by (b.year - a.year) desc) rank from years a join years b on a.id = b.id and b.year > a.year where b.year - a.year = (select count(*)-1 from years a1 where a.id = a1.id and a1.year between a.year and b.year))where rank = 1编辑 已更新，以显示最长延伸的开始/结束年份。
SQLFiddle
Access SQL查询：查找表中每个不同条目的最新日期的行
全部，
我敢肯定这是一个非常简单的SQL查询问题，但是我敢肯定有一个很好的方法，也很糟糕的方法来做到这一点。留给我自己的设备，我有可能以后者结束。所以…
我在Access中有一个表，其中的数据如下所示：
ID Value As_of1173 156 200906011173 173 200812011173 307 200809011173 305 20080601127 209 20090301127 103 20081201127 113 20080901127 113 200806011271 166 200902011271 172 200812011271 170 200809011271 180 20080601...我想要获取的是每个具有唯一“截止日期”日期（采用YYYYMM格式）的唯一ID的“值”。
因此，我的结果集应如下所示：
ID Value As_of1173 156 20090601127 209 200903011271 166 20090201请注意，不同的ID将具有不同的“截止日期”日期。换句话说，我不能简单地从全局上标识最近的日期，然后选择具有该日期的每一行。
就其价值而言，该表总共约有200,000行，并具有约10,000个唯一ID。
提前谢谢了！
答案1
小编典典如果同时需要日期和值，则需要进行联接：
SELECT ID, Value,As_of from yourTable a inner join (SELECT ID, MAX(As_of) as As_of from yourTable group by ID) b on a.ID=b.ID and a.As_of = b.As_of
c# – 如何使用LINQ查找词典列表中每个键的最大值？
许多词典中都有相同的键,但不是全部.
所以我的问题是：使用LINQ如何在所有字典中找到与每个不同键相关联的最大值？
例如,给出以下输入：
var data = new List<Dictionary<string,int>>
{
new Dictionary<string,int> {{"alpha",4},{"gorilla",2},{"gamma",3}},new Dictionary<string,1},{"beta",3},1}},int> {{"monkey",2}},};
我想要某种包含以下内容的集合：
{"alpha",{"monkey",2}
(我现在正在遍历列表并自己跟踪事物,真的只是想知道是否有更好的LINQ式方式)
编辑：我也不知道字符串键是什么提前
解决方法
var results = data.SelectMany(d => d)
.GroupBy(d => d.Key)
.Select(g => new
{
GroupName = g.Key,MaxValue = g.Max(i => i.Value)
});
并测试以上,使用此
foreach (var item in results)
{
Console.WriteLine(item);
}
获得以下输出…
{ GroupName = alpha,MaxValue = 4 }
{ GroupName = gorilla,MaxValue = 2 }
{ GroupName = gamma,MaxValue = 3 }
{ GroupName = beta,MaxValue = 3 }
{ GroupName = monkey,MaxValue = 2 }
dapper之连接数据库（Oracle，SQL Server，MySql）
因为项目需求，需要项目同时可以访问三个数据库，因此本人经过一番研究，得出以下代码。
1.建立公共连接抽象类(DataBase)
1 public abstract class DataBase
2 {
3 /// <summary>
4 ///
5 /// </summary>
6 public abstract string ConnectionString { get; }
7
8 /// <summary>
9 ///
10 /// </summary>
11 /// <param name="cmd"></param>
12 /// <param name="pName"></param>
13 /// <param name="value"></param>
14 /// <param name="type"></param>
15 /// <returns></returns>
16
17 public DbParameter CreateParameter(DbCommand cmd, String pName, Object value, System.Data.DbType type)
18 {
19 var p = cmd.CreateParameter();
20 p.ParameterName = pName;
21 p.Value = (value == null ? DBNull.Value : value);
22 p.DbType = type;
23 return p;
24 }
25 /// <summary>
26 ///
27 /// </summary>
28 /// <returns></returns>
29 public abstract DbConnection CreateConnection();
30 /// <summary>
31 /// 返回List
32 /// </summary>
33 /// <typeparam name="T"></typeparam>
34 /// <param name="sql"></param>
35 /// <param name="paramObject"></param>
36 /// <returns></returns>
37 public List<T> Select<T>(string sql, Object paramObject = null)
38 {
39
40 try
41 {
42 using (DbConnection conn = CreateConnection())
43 {
44 conn.Open();
45 var list = Dapper.SqlMapper.Query<T>(conn, sql, paramObject);
46 return list.ToList<T>();
47 }
48
49 }
50 catch (Exception ex)
51 {
52 Logs.Write(LogType.Error, ex.Message,this.GetType());
53 return null;
54 }
55 }
56 /// <summary>
57 /// 返回List
58 /// </summary>
59 /// <typeparam name="T"></typeparam>
60 /// <param name="tabName">表名</param>
61 /// <param name="paramObject"></param>
62 /// <returns></returns>
63 public List<T> Select<T>()
64 {
65 try
66 {
67 using (DbConnection conn = CreateConnection())
68 {
69 conn.Open();
70 var list = Dapper.SqlMapper.Query<T>(conn, "SELECT * FROM " + typeof(T).Name, null);
71 return list.ToList<T>();
72 }
73 }
74 catch (Exception ex)
75 {
76 Logs.Write(LogType.Error, ex.Message, this.GetType());
77 return null;
78 }
79 }
80 public int Insert<T>(T t)
81 {
82 try
83 {
84 using (DbConnection conn = CreateConnection())
85 {
86 conn.Open();
87 var id = conn.Insert(t);
88 return id ?? 0;
89 }
90 }
91 catch (Exception ex)
92 {
93 Logs.Write(LogType.Error, ex.Message, this.GetType());
94 return -1;
95 }
96 }
97 public int Delete<T>(T t)
98 {
99 try
100 {
101 using (DbConnection conn = CreateConnection())
102 {
103 conn.Open();
104 return conn.Delete(t);
105 }
106 }
107 catch (Exception ex)
108 {
109 Logs.Write(LogType.Error, ex.Message, this.GetType());
110 return -1;
111 }
112 }
113 public int Update<T>(T t)
114 {
115 try
116 {
117 using (DbConnection conn = CreateConnection())
118 {
119 conn.Open();
120 return conn.Update(t);
121 }
122 }
123 catch (Exception ex)
124 {
125 Logs.Write(LogType.Error, ex.Message, this.GetType());
126 return -1;
127 }
128 }
129 public string InsertByGuid<T>(T t)
130 {
131 try
132 {
133 using (DbConnection conn = CreateConnection())
134 {
135 conn.Open();
136 return conn.Insert<string,T>(t);
137 }
138 }
139 catch (Exception ex)
140 {
141 Logs.Write(LogType.Error, ex.Message, this.GetType());
142 return "";
143 }
144 }
145 public List<T> GetList<T>(string sql, Object paramObject = null)
146 {
147 try
148 {
149 using (DbConnection conn = CreateConnection())
150 {
151 conn.Open();
152 return conn.Query<T>(sql, paramObject).ToList();
153 }
154 }
155 catch (Exception ex)
156 {
157 Logs.Write(LogType.Error, ex.Message, this.GetType());
158 return null;
159 }
160 }
161 public IEnumerable<dynamic> GetList(string sql, Object paramObject = null)
162 {
163 try
164 {
165 using (DbConnection conn = CreateConnection())
166 {
167 conn.Open();
168 return conn.Query(sql, paramObject);
169 }
170 }
171 catch (Exception ex)
172 {
173 Logs.Write(LogType.Error, ex.Message, this.GetType());
174 return null;
175 }
176 }
177 /// <summary>
178 ///
179 /// </summary>
180 /// <param name="sql"></param>
181 /// <param name="paramObject"></param>
182 /// <returns></returns>
183 public List<dynamic> Select(string sql, Object paramObject = null)
184 {
185 DbConnection conn = null;
186 try
187 {
188 conn = CreateConnection();
189 conn.Open();
190 var list = Dapper.SqlMapper.Query(conn, sql, paramObject);
191 return list.ToList<dynamic>();
192 }
193 catch (Exception ex)
194 {
195 Logs.Write(LogType.Error, ex.Message, this.GetType());
196 return null;
197 }
198 finally
199 {
200 if (conn != null)
201 conn.Close();
202 }
203 }
204
205 /// <summary>
206 /// 获取一条数据
207 /// </summary>
208 /// <param name="sql"></param>
209 /// <param name="paramObject"></param>
210 /// <returns></returns>
211 public dynamic Single(string sql, Object paramObject = null)
212 {
213 DbConnection conn = null;
214 try
215 {
216 conn = CreateConnection();
217 conn.Open();
218 var list = Dapper.SqlMapper.QuerySingleOrDefault<dynamic>(conn, sql, paramObject);
219 return list;
220 }
221 catch (Exception ex)
222 {
223 Logs.Write(LogType.Error, ex.Message, this.GetType());
224 return null;
225 }
226 finally
227 {
228 if (conn != null)
229 conn.Close();
230 }
231 }
232
233 /// <summary>
234 /// 获取一条数据
235 /// </summary>
236 /// <typeparam name="T"></typeparam>
237 /// <param name="sql"></param>
238 /// <param name="paramObject"></param>
239 /// <returns></returns>
240 public T Single<T>(string sql, Object paramObject = null)
241 {
242
243 DbConnection conn = null;
244 try
245 {
246 conn = CreateConnection();
247 conn.Open();
248 var list = Dapper.SqlMapper.QuerySingleOrDefault<T>(conn, sql, paramObject);
249 return list;
250 }
251 catch (Exception ex)
252 {
253 Logs.Write(LogType.Error, ex.Message, this.GetType());
254 return default(T);
255 }
256 finally
257 {
258 if (conn != null)
259 conn.Close();
260 }
261 }
262
263 /// <summary>
264 /// 获取一行一列
265 /// </summary>
266 /// <typeparam name="T"></typeparam>
267 /// <param name="sql"></param>
268 /// <param name="paramObject"></param>
269 /// <returns></returns>
270 public T ExecuteScalar<T>(string sql, Object paramObject = null)
271 {
272
273 DbConnection conn = null;
274 try
275 {
276 conn = CreateConnection();
277 conn.Open();
278 T t = Dapper.SqlMapper.ExecuteScalar<T>(conn, sql, paramObject);
279 return t;
280 }
281 catch (Exception ex)
282 {
283 Logs.Write(LogType.Error, ex.Message, this.GetType());
284 return default(T);
285 }
286 finally
287 {
288 if (conn != null)
289 conn.Close();
290 }
291 }
292
293 /// <summary>
294 /// 返回受影响行数
295 /// </summary>
296 /// <param name="sql"></param>
297 /// <param name="paramObject"></param>
298 /// <returns></returns>
299 public int Execute(string sql, Object paramObject = null)
300 {
301 DbConnection conn = null;
302 try
303 {
304 conn = CreateConnection();
305 conn.Open();
306 int count = Dapper.SqlMapper.Execute(conn, sql, paramObject);
307 return count;
308 }
309 catch (Exception ex)
310 {
311 Logs.Write(LogType.Error, ex.Message, this.GetType());
312 return 0;
313 }
314 finally
315 {
316 if (conn != null)
317 conn.Close();
318 }
319 }
320 }2.建立3个不同数据库连接类（OracleDataBase、SqlDataBase、MySqlDataBase）继承(DataBase)类
1 public class OracleDataBase : DataBase
2 {
3 public override string ConnectionString
4 {
5 get
6 {
7 return System.Configuration.ConfigurationManager.ConnectionStrings["OracleConnection"].ToString();
8 }
9 }
10 /// <summary>
11 /// 常用
12 /// </summary>
13 /// <returns></returns>
14 public override DbConnection CreateConnection()
15 {
16 Oracle.ManagedDataAccess.Client.OracleConnection conn = new Oracle.ManagedDataAccess.Client.OracleConnection(ConnectionString);
17 conn.ConnectionString = ConnectionString;
18 return null;
19 }
20 } 1 public class SqlDataBase : DataBase
2 {
3 /// <summary>
4 ///
5 /// </summary>
6 public override string ConnectionString
7 {
8 get
9 {
10 return System.Configuration.ConfigurationManager.ConnectionStrings["SqlConnection"].ToString();
11 }
12 }
13 /// <summary>
14 ///
15 /// </summary>
16 /// <returns></returns>
17 public override DbConnection CreateConnection()
18 {
19 SqlConnection conn = new SqlConnection(ConnectionString);
20 conn.ConnectionString = ConnectionString;
21 return conn;
22 }
23
24 } 1 public class MySqlDataBase : DataBase
2 {
3 /// <summary>
4 ///
5 /// </summary>
6 public override string ConnectionString
7 {
8 get
9 {
10 return System.Configuration.ConfigurationManager.ConnectionStrings["MySqlConnection"].ToString();
11 }
12 }
13 /// <summary>
14 /// 常用
15 /// </summary>
16 /// <returns></returns>
17 public override DbConnection CreateConnection()
18 {
19 MySql.Data.MySqlClient.MySqlConnection conn = new MySql.Data.MySqlClient.MySqlConnection(ConnectionString);
20 return conn;
21 }
22 }3.访问不同的连接
1 public List<T> GetList<T>()
2 {
3 var db = new SqlDataBase();
4 return db.Select<T>();
5 }
6 public List<T> GetList<T>()
7 {
8 var db = new OracleDataBase();
9 return db.Select<T>();
10 }
11 public List<T> GetList<T>()
12 {
13 var db = new MySqlDataBase();
14 return db.Select<T>();
15 }以上代码就是访问不同的数据库的列表信息，其他增删改和上面的差不多写法，如果还有其他问题，请评论！
原文出处：https://www.cnblogs.com/lvphon/p/11758817.html
Django 数据库连接配置（Oracle、Mysql）
一、Django Oracle 连接配置
DATABASES = {
''default'': {
''ENGINE'': ''django.db.backends.oracle'',
''NAME'': ''DEMO'',
''USER'': ''demo1'',
''PASSWORD'': ''demo1'',
''HOST'': "10.XXX.XXX.XXX", # Set to empty string for localhost
''PORT'': ''1521'', #端口
}
}
二、Django Mysql 连接配置
DATABASES = {
''default'': {
''ENGINE'': ''django.db.backends.mysql'',
#数据库名字
''NAME'': ''study'',
''USER'': ''root'',
''PASSWORD'': ''centos'',
''HOST'': ''127.0.0.1'',
''PORT'': ''3306'',
''OPTIONS'': {
''autocommit'': True,
''init_command'': "SET sql_mode=''STRICT_TRANS_TABLES''",
},
}
}
三、注意事项
1、查看 django 版本
import django
print(django.VERSION)
2、关联数据库
python manage.py makemigrations
python manage.py migrate
1）python manage.py migrate 报错
ORA-02000: missing ALWAYS keyword
ORA-02000: missing ALWAYS keyword 问题是因为 django 默认为每个表增加序列字段，django2.0 使用了 oracle12 新特性 ALWAYS keyword（而旧版本不支持自增长序列字段），因此如果你的服务器 oracle 不是 12c 版本使用 django2.0 就会出现这个错误，要解决这个问题只有使用低版本的 djiango 或服务器升级到 oracle12c，再或者花精力去修改 ORM 框架文件！以上是我的理解，不知正确与否，待验证！
降低版本在执行
2）python manage.py migrate 报错
修改 setting 中的 MIDDLEWARE 为 MIDDLEWARE_CLASSES
3）python manage.py migrate 报错
再次报错，原因是，cx_Oracle6.0 以及以上版本删除 numbersAsStrings 方法，既然 6.0 删除了，只能降级
降低版本
pip install cx-oracle==5.3
报错
为了绕过这个错误，在网上找到了一个封装好的 cx-Oracle 版本
https://www.lfd.uci.edu/~gohlke/pythonlibs/ 从这里面下载
只有这一个版本安装成功（我的是 64 位）
导入 cx_Oracle 测试
cx_Oracle5.2 ImportError: DLL load failed: 找不到指定的程序。
解决方法。。。。没有解决
回滚 cx_Oracle 位原来的 7 版本
在 base.py 文件中注销了 self.cursor.numbersAsStrings = True
4）python manage.py migrate 报错
因为 cx_Oracle 位原来的 7 版本对应的是 Oracle12c 版本，12c 增加了类似 MySQL 的表的主键自增，
导致插入数据 id 为空，插入比进去，这个 ID 是表的主键，因此间表的主键删除，插入数据后，在加上。
。。。。
再次执行，表已存在。。。直接放弃
关于查找表中每个ID的最大连续年份和Oracle SQL的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于Access SQL查询：查找表中每个不同条目的最新日期的行、c# – 如何使用LINQ查找词典列表中每个键的最大值？、dapper之连接数据库（Oracle，SQL Server，MySql）、Django 数据库连接配置（Oracle、Mysql）等相关内容，可以在本站寻找。
本文标签：
