• 关于

    SQL连接(JOIN)

    的搜索结果

问题

如何使用ID联接多个SQL表?

保持可爱mmm 2020-05-11 10:31:56 0 浏览量 回答数 1

问题

老司机求带:php中的数据库操作。? 400 报错

爱吃鱼的程序员 2020-06-01 11:21:12 0 浏览量 回答数 1

问题

Dataframes join在Spark Scala中返回空结果

社区小助手 2019-12-01 19:23:53 549 浏览量 回答数 1

阿里云高校特惠,助力学生创业梦!0元体验,快速入门云计算!

学生动手场景应用,快速了解并掌握云服务器的各种新奇玩法!

问题

mysql多表连接查询,如何写sql语句?

落地花开啦 2019-12-01 19:54:11 1186 浏览量 回答数 1

问题

Window.rowsBetween - 仅考虑满足特定条件的行(例如,不为null)

社区小助手 2019-12-01 19:30:00 1608 浏览量 回答数 1

问题

从Unix中的SQL Server DMZMGMT SQL Server数据库获取TimeValue

祖安文状元 2020-01-03 16:18:23 0 浏览量 回答数 1

回答

假设您想要用户的每个可能的位置组合,您只需要在USER_ID上进行连接,然后减去日期列。这里的一个技巧是使用unix_timestamp将日期时间数据解析为支持减法操作的整数。 示例代码: from pyspark.sql.functions import unix_timestamp, col, datediff data = [ (1, 1001, '19:11:39 5-2-2010'), (1, 6022, '17:51:19 6-6-2010'), (1, 1041, '11:11:39 5-2-2010'), (2, 9483, '10:51:23 3-2-2012'), (2, 4532, '11:11:11 4-5-2012'), (3, 4374, '03:21:23 6-9-2013'), (3, 4334, '04:53:13 4-5-2013') ] df = spark.createDataFrame(data, ['USER_ID', 'location', 'timestamp'])df = df.withColumn('timestamp', unix_timestamp('timestamp', 'HH:mm:ss dd-MM-yyyy')) Renaming columns to avoid conflicts after join df2 = df.selectExpr('USER_ID as USER_ID2', 'location as location2', 'timestamp as timestamp2')cartesian = df.join(df2, col("USER_ID") == col("USER_ID2"), "inner") Filter to get rid of reversed duplicates, and rows where location is same on both sides pairs = cartesian.filter("location < location2") \ .drop("USER_ID2") \ .withColumn("diff", col("timestamp2") - col("timestamp")) pairs.show()

社区小助手 2019-12-02 01:47:52 0 浏览量 回答数 0

问题

加入两个列表列值,如Pyspark中的zip

一码平川MACHEL 2019-12-01 19:31:44 704 浏览量 回答数 1

回答

问题是,一旦您持久保存数据,second_id就会将其合并到缓存表中,不再被视为常量。因此,计划程序无法再推断查询应该表示为笛卡尔积,并使用标准SortMergeJoin的哈希分区second_id。在不使用持久性的情况下实现相同的结果将是微不足道的 udffrom pyspark.sql.functions import lit, pandas_udf, PandasUDFType@pandas_udf('integer', PandasUDFType.SCALAR) def identity(x):return x second_df = second_df.withColumn('second_id', identity(lit(1)))result_df = first_df.join(second_df, first_df.first_id == second_df.second_id, 'inner') result_df.explain()== Physical Plan ==*(6) SortMergeJoin [cast(first_id#4 as int)], [second_id#129], Inner:- *(2) Sort [cast(first_id#4 as int) ASC NULLS FIRST], false, 0: +- Exchange hashpartitioning(cast(first_id#4 as int), 200): +- *(1) Filter isnotnull(first_id#4): +- Scan ExistingRDD[first_id#4]+- *(5) Sort [second_id#129 ASC NULLS FIRST], false, 0 +- Exchange hashpartitioning(second_id#129, 200) +- *(4) Project [some_value#6, pythonUDF0#154 AS second_id#129] +- ArrowEvalPython [identity(1)], [some_value#6, pythonUDF0#154] +- *(3) Project [some_value#6] +- *(3) Filter isnotnull(pythonUDF0#153) +- ArrowEvalPython [identity(1)], [some_value#6, pythonUDF0#153] +- Scan ExistingRDD[some_value#6]然而,SortMergeJoin这不是你应该尝试在这里实现的。使用常量键,除了玩具数据外,它会导致极端的数据偏差,并且可能会失败。然而,笛卡尔积虽然价格昂贵,但不会遇到这个问题,因此这里应该优先考虑。因此,它建议启用交叉连接或使用显式交叉连接语法(Spark 2.x的spark.sql.crossJoin.enabled)并继续。一个悬而未决的问题仍然是如何在缓存数据时防止意外行为。不幸的是,我没有为此做好准备。我相当确定可以使用自定义优化器规则,但这不是单独用Python完成的事情。

社区小助手 2019-12-02 01:47:43 0 浏览量 回答数 0

问题

在PySpark的文字列中检测到INNER连接的笛卡尔积

社区小助手 2019-12-01 19:25:26 644 浏览量 回答数 1

回答

查看greemplum资源队列状态SELECT * FROM gp_toolkit.gp_resqueue_status; 查看greemplum资源队列锁SELECT * FROM gp_toolkit.gp_locks_on_resqueue WHERE lorwaiting='true'; 查看greemplum资源队列优先级select *  from gp_toolkit.gp_resq_priority_statement; 查看greemplum所有连接 类似mysql SHOW PROCESSLISTselect * from pg_stat_activity; -- 所有状态的连接 greemplum磁盘使用,通过SQL查看Greenplum中用了多少空间select datname,pg_size_pretty(pg_database_size(datname)) from pg_database;   查看greemplum节点状态select * from gp_segment_configuration ttselect * from gp_segment_configuration tt where tt.status='d'; -- 状态为down 节点故障等历史信息select * from gp_configuration_history tt order by 1 desc ; 数据倾斜SELECT    t1.gp_segment_id,    t1.count_tatol,    round(t1.count_tatol-(AVG(t1.count_tatol)  over()) ,0)FROM    (        SELECT            gp_segment_id,            COUNT (*) count_tatol        FROM             -- 要查的表        GROUP BY            gp_segment_id    ) t1order by 3 greemplum表或索引大小 (占用空间)select pg_size_pretty(pg_relation_size('gp_test')); greemplum表和索引大小(占用空间)select pg_size_pretty(pg_total_relation_size('gp_test')); greemplum查看指定数据库大小(占用空间)select pg_size_pretty(pg_database_size('postgres')); greemplum所有数据库大小(占用空间)select datname,pg_size_pretty(pg_database_size(datname)) from pg_database; 查看greemplum数据分布情况select gp_segment_id,count(*) from gp_test group by gp_segment_id order by 1; 查看greemplum数据表更新时间SELECT    *FROM    pg_stat_last_operation,    pg_classWHERE    objid = oidAND relname = 'base_common'; -- 表名 通过sql 获取greemplum表的预估数据量select    relname,    reltuples::int as totalfrom    pg_classwhere    relname = 'base_common'    and relnamespace = (select oid from pg_namespace where nspname = 'positions'); 通过sql 获取greemplum获取分布键 SELECT string_agg(att.attname,',' order by attrnums) as distribution        FROM gp_distribution_policy a,pg_attribute att        WHERE a.localoid ='bi_data.schoolmate_relations'::regclass      and a.localoid = att.attrelid      and att.attnum = any(a.attrnums); 通过sql获取 greemplum指定表结构 SELECT            attname, typname     FROM           pg_attribute           INNER JOIN pg_class  ON pg_attribute.attrelid = pg_class.oid           INNER JOIN pg_type   ON pg_attribute.atttypid = pg_type.oid           INNER JOIN pg_namespace on pg_class.relnamespace=pg_namespace.oid  --     WHERE           pg_attribute.attnum > 0       AND attisdropped <> 't'       AND pg_namespace.nspname='resumes'       AND pg_class.relname= 'base_common'--     and pg_class.relname ~~* any(array['%some%', '%someelse']));order by  pg_attribute.attnum

来一点幽默 2019-12-02 01:35:35 0 浏览量 回答数 0

回答

流处理,听起来很高大上啊,其实就是分块读取。有这么一些情况,有一个很大的几个G的文件,没办法一次处理,那么就分批次处理,一次处理1百万行,接着处理下1百万行,慢慢地总是能处理完的。 使用类似迭代器的方式 data=pd.read_csv(file, chunksize=1000000)for sub_df in data: print('do something in sub_df here') 1234索引 Series和DataFrame都是有索引的,索引的好处是快速定位,在涉及到两个Series或DataFrame时可以根据索引自动对齐,比如日期自动对齐,这样可以省去很多事。 缺失值 pd.isnull(obj)obj.isnull()12将字典转成数据框,并赋予列名,索引 DataFrame(data, columns=['col1','col2','col3'...], index = ['i1','i2','i3'...]) 12查看列名 DataFrame.columns 查看索引 DataFrame.index 重建索引 obj.reindex(['a','b','c','d','e'...], fill_value=0] 按给出的索引顺序重新排序,而不是替换索引。如果索引没有值,就用0填充 就地修改索引 data.index=data.index.map(str.upper)12345列顺序重排(也是重建索引) DataFrame.reindex[columns=['col1','col2','col3'...])` 也可以同时重建index和columns DataFrame.reindex[index=['a','b','c'...],columns=['col1','col2','col3'...])12345重建索引的快捷键 DataFrame.ix[['a','b','c'...],['col1','col2','col3'...]]1重命名轴索引 data.rename(index=str.title,columns=str.upper) 修改某个索引和列名,可以通过传入字典 data.rename(index={'old_index':'new_index'}, columns={'old_col':'new_col'}) 12345查看某一列 DataFrame['state'] 或 DataFrame.state1查看某一行 需要用到索引 DataFrame.ix['index_name']1添加或删除一列 DataFrame['new_col_name'] = 'char_or_number' 删除行 DataFrame.drop(['index1','index2'...]) 删除列 DataFrame.drop(['col1','col2'...],axis=1) 或 del DataFrame['col1']1234567DataFrame选择子集 类型 说明obj[val] 选择一列或多列obj.ix[val] 选择一行或多行obj.ix[:,val] 选择一列或多列obj.ix[val1,val2] 同时选择行和列reindx 对行和列重新索引icol,irow 根据整数位置选取单列或单行get_value,set_value 根据行标签和列标签选择单个值针对series obj[['a','b','c'...]]obj['b':'e']=512针对dataframe 选择多列 dataframe[['col1','col2'...]] 选择多行 dataframe[m:n] 条件筛选 dataframe[dataframe['col3'>5]] 选择子集 dataframe.ix[0:3,0:5]1234567891011dataframe和series的运算 会根据 index 和 columns 自动对齐然后进行运算,很方便啊 方法 说明add 加法sub 减法div 除法mul 乘法 没有数据的地方用0填充空值 df1.add(df2,fill_value=0) dataframe 与 series 的运算 dataframe - series 规则是: -------- v 指定轴方向 dataframe.sub(series,axis=0)规则是:-------- --- | | | | ----->| | | | | | | | | | | | -------- ---12345678910111213141516171819202122apply函数 f=lambda x:x.max()-x.min() 默认对每一列应用 dataframe.apply(f) 如果需要对每一行分组应用 dataframe.apply(f,axis=1)1234567排序和排名 默认根据index排序,axis = 1 则根据columns排序 dataframe.sort_index(axis=0, ascending=False) 根据值排序 dataframe.sort_index(by=['col1','col2'...]) 排名,给出的是rank值 series.rank(ascending=False) 如果出现重复值,则取平均秩次 在行或列上面的排名 dataframe.rank(axis=0)12345678910111213描述性统计 方法 说明count 计数describe 给出各列的常用统计量min,max 最大最小值argmin,argmax 最大最小值的索引位置(整数)idxmin,idxmax 最大最小值的索引值quantile 计算样本分位数sum,mean 对列求和,均值mediam 中位数mad 根据平均值计算平均绝对离差var,std 方差,标准差skew 偏度(三阶矩)Kurt 峰度(四阶矩)cumsum 累积和Cummins,cummax 累计组大致和累计最小值cumprod 累计积diff 一阶差分pct_change 计算百分数变化唯一值,值计数,成员资格 obj.unique()obj.value_count()obj.isin(['b','c'])123处理缺失值 过滤缺失值 只要有缺失值就丢弃这一行 dataframe.dropna() 要求全部为缺失才丢弃这一行 dataframe.dropna(how='all') 根据列来判断 dataframe.dropna(how='all',axis=1) 填充缺失值 1.用0填充 df.fillna(0) 2.不同的列用不同的值填充 df.fillna({1:0.5, 3:-1}) 3.用均值填充 df.fillna(df.mean()) 此时axis参数同前面, 123456789101112131415161718192021将列转成行索引 df.set_index(['col1','col2'...])1数据清洗,重塑 合并数据集 取 df1,df2 都有的部分,丢弃没有的 默认是inner的连接方式 pd.merge(df1,df2, how='inner') 如果df1,df2的连接字段名不同,则需要特别指定 pd.merge(df1,df2,left_on='l_key',right_on='r_key') 其他的连接方式有 left,right, outer等。 如果dataframe是多重索引,根据多个键进行合并 pd.merge(left, right, on=['key1','key2'],how = 'outer') 合并后如果有重复的列名,需要添加后缀 pd.merge(left, right, on='key1', suffixes=('_left','_right'))1234567891011121314索引上的合并 针对dataframe中的连接键不是列名,而是索引名的情况。 pd.merge(left, right, left_on = 'col_key', right_index=True) 即左边的key是列名,右边的key是index。 多重索引 pd.merge(left, right, left_on=['key1','key2'], right_index=True)123456dataframe的join方法 实现按索引合并。 其实这个join方法和数据库的join函数是以一样的理解 left.join(right, how='outer') 一次合并多个数据框 left.join([right1,right2],how='outer')123456轴向连接(更常用) 连接:concatenation 绑定:binding 堆叠:stacking列上的连接 np.concatenation([df1,df2],axis=1) #np包pd.concat([df1,df2], axis=1) #pd包 和R语言中的 cbind 是一样的 如果axis=0,则和 rbind 是一样的 索引对齐,没有的就为空 join='inner' 得到交集 pd.concat([df1,df2], axis=1, join='innner') keys 参数,还没看明白 ignore_index=True,如果只是简单的合并拼接而不考虑索引问题。 pd.concat([df1,df2],ignore_index=True)123456789101112131415合并重复数据 针对可能有索引全部或者部分重叠的两个数据集 填充因为合并时索引赵成的缺失值 where函数 where即if-else函数 np.where(isnull(a),b,a)12combine_first方法 如果a中值为空,就用b中的值填补 a[:-2].combine_first(b[2:]) combine_first函数即对数据打补丁,用df2的数据填充df1中的缺失值 df1.combine_first(df2)12345重塑层次化索引 stact:将数据转为长格式,即列旋转为行 unstack:转为宽格式,即将行旋转为列result=data.stack()result.unstack()12长格式转为宽格式 pivoted = data.pivot('date','item','value') 前两个参数分别是行和列的索引名,最后一个参数则是用来填充dataframe的数据列的列名。如果忽略最后一个参数,得到的dataframe会带有层次化的列。 123透视表 table = df.pivot_table(values=["Price","Quantity"], index=["Manager","Rep"], aggfunc=[np.sum,np.mean], margins=True)) values:需要对哪些字段应用函数 index:透视表的行索引(row) columns:透视表的列索引(column) aggfunc:应用什么函数 fill_value:空值填充 margins:添加汇总项 然后可以对透视表进行筛选 table.query('Manager == ["Debra Henley"]')table.query('Status == ["pending","won"]')123456789101112131415移除重复数据 判断是否重复 data.duplicated()` 移除重复数据 data.drop_duplicated() 对指定列判断是否存在重复值,然后删除重复数据 data.drop_duplicated(['key1'])123456789交叉表 是一种用于计算分组频率的特殊透视表. 注意,只对离散型的,分类型的,字符型的有用,连续型数据是不能计算频率这种东西的。 pd.crosstab(df.col1, df.col2, margins=True)1类似vlookup函数 利用函数或映射进行数据转换 1.首先定义一个字典 meat_to_animal={ 'bacon':'pig', 'pulled pork':'pig', 'honey ham':'cow' } 2.对某一列应用一个函数,或者字典,顺便根据这一列的结果创建新列 data['new_col']=data['food'].map(str.lower).map(meat_to_animal)123456789替换值 data.replace(-999,np.na) 多个值的替换 data.replace([-999,-1000],np.na) 对应替换 data.replace([-999,-1000],[np.na,0]) 对应替换也可以传入一个字典 data.replace({-999:np.na,-1000:0})123456789离散化 定义分割点 简单分割(等宽分箱) s=pd.Series(range(100))pd.cut(s, bins=10, labels=range(10)) bins=[20,40,60,80,100] 切割 cats = pd.cut(series,bins) 查看标签 cats.labels 查看水平(因子) cats.levels 区间计数 pd.value_count(cats) 自定义分区的标签 group_names=['youth','youngAdult','MiddleAge','Senior']pd.cut(ages,bins,labels=group_names)1234567891011121314151617181920212223分位数分割 data=np.random.randn(1000)pd.qcut(data,4) #四分位数 自定义分位数,包含端点 pd.qcut(data,[0,0.3,0.5,0.9,1])12345异常值 查看各个统计量 data.describe() 对某一列 col=data[3]col[np.abs(col)>3] 选出全部含有“超过3或-3的值的行 data[(np.abs(data)>3).any(1)] 异常值替换 data[np.abs(data)>3]=np.sign(data)*312345678910111213抽样 随机抽取k行 df.take(np.random.permutation(len(df))[:k]) 随机抽取k行,但是k可能大于df的行数 可以理解为过抽样了 df.take(np.random.randint(0,len(df),size=k))1234567数据摊平处理 相当于将类别属性转成因子类型,比如是否有车,这个字段有3个不同的值,有,没有,过段时间买,那么将会被编码成3个字段,有车,没车,过段时间买车,每个字段用0-1二值填充变成数值型。 对摊平的数据列增加前缀 dummies = pd.get_dummies(df['key'],prefix='key') 将摊平产生的数据列拼接回去 df[['data1']].join(dummies)12345字符串操作 拆分 strings.split(',') 根据正则表达式切分 re.split('s+',strings) 连接 'a'+'b'+'c'...或者'+'.join(series) 判断是否存在 's' in strings`strings.find('s') 计数 strings.count(',') 替换 strings.replace('old','new') 去除空白字符 s.strip()12345678910111213141516171819202122232425正则表达式 正则表达式需要先编译匹配模式,然后才去匹配查找,这样能节省大量的CPU时间。 re.complie:编译 findall:匹配所有 search:只返回第一个匹配项的起始和结束地址 match:值匹配字符串的首部 sub:匹配替换,如果找到就替换 原始字符串 strings = 'sdf@153.com,dste@qq.com,sor@gmail.com' 编译匹配模式,IGNORECASE可以在使用的时候对大小写不敏感 pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'regex = re.compile(pattern,flags=re.IGNORECASE) 匹配所有 regex.findall(strings) 使用search m = regex.search(strings) #获取匹配的地址strings[m.start():m.end()] 匹配替换 regex.sub('new_string', strings)12345678910111213141516根据模式再切分 将模式切分,也就是将匹配到的进一步切分,通过pattern中的括号实现. pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'regex = re.compile(pattern)regex.findall(strings) 如果使用match m=regex.match(string)m.groups() 效果是这样的 suzyu123@163.com --> [(suzyu123, 163, com)] 获取 list-tuple 其中的某一列 matches.get(i)12345678910111213分组聚合,计算 group_by技术 根据多个索引分组,然后计算均值 means = df['data1'].groupby([df['index1'],df['index2']).mean() 展开成透视表格式 means.unstack()12345分组后价将片段做成一个字典 pieces = dict(list(df.groupby('index1'))) pieces['b']123groupby默认是对列(axis=0)分组,也可以在行(axis=1)上分组 语法糖,groupby的快捷函数 df.groupby('index1')['col_names']df.groupby('index1')[['col_names']] 是下面代码的语法糖 df['col_names'].groupby(df['index1']) df.groupby(['index1','index2'])['col_names'].mean()1234567通过字典或series进行分组 people = DataFrame(np.random.randn(5, 5), columns=['a', 'b', 'c', 'd', 'e'], index=['Joe', 'Steve', 'Wes', 'Jim','Travis']) 选择部分设为na people.ix[2:3,['b','c']]=np.na mapping = {'a': 'red', 'b': 'red', 'c': 'blue', 'd': 'blue', 'e': 'red', 'f' : 'orange'} people.groupby(mapping,axis=1).sum()1234567891011通过函数进行分组 根据索引的长度进行分组 people.groupby(len).sum()12数据聚合 使用自定义函数 对所有的数据列使用自定义函数 df.groupby('index1').agg(myfunc) 使用系统函数 df.groupby('index1')['data1']describe()12345根据列分组应用多个函数 分组 grouped = df.groupby(['col1','col2']) 选择多列,对每一列应用多个函数 grouped['data1','data2'...].agg(['mean','std','myfunc'])12345对不同列使用不同的函数 grouped = df.groupby(['col1','col2']) 传入一个字典,对不同的列使用不同的函数 不同的列可以应用不同数量的函数 grouped.agg({'data1':['min','max','mean','std'], 'data2':'sum'}) 123456分组计算后重命名列名 grouped = df.groupby(['col1','col2']) grouped.agg({'data1':[('min','max','mean','std'),('d_min','d_max','d_mean','d_std')], 'data2':'sum'}) 1234返回的聚合数据不要索引 df.groupby(['sex','smoker'], as_index=False).mean()1分组计算结果添加前缀 对计算后的列名添加前缀 df.groupby('index1').mean().add_prefix('mean_')12将分组计算后的值替换到原数据框 将函数应用到各分组,再将分组计算的结果代换原数据框的值 也可以使用自定义函数 df.groupby(['index1','index2'...]).transform(np.mean)123更一般化的apply函数 df.groupby(['col1','col2'...]).apply(myfunc) df.groupby(['col1','col2'...]).apply(['min','max','mean','std'])123禁用分组键 分组键会跟原始对象的索引共同构成结果对象中的层次化索引 df.groupby('smoker', group_keys=False).apply(mean)1分组索引转成df的列 某些情况下,groupby的as_index=False参数并没有什么用,得到的还是一个series,这种情况一般是尽管分组了,但是计算需要涉及几列,最后得到的还是series,series的index是层次化索引。这里将series转成dataframe,series的层次化索引转成dataframe的列。 def fmean(df): """需要用两列才能计算最后的结果""" skus=len(df['sku'].unique()) sums=df['salecount'].sum() return sums/skus 尽管禁用分组键,得到的还是series salemean=data.groupby(by=['season','syear','smonth'],as_index=False).apply(fmean) 将series转成dataframe,顺便设置索引 sub_df = pd.DataFrame(salemean.index.tolist(),columns=salemean.index.names,index=salemean.index) 将groupby的结果和sub_df合并 sub_df['salemean']=salemean12345678910111213桶分析与分位数 对数据切分段,然后对每一分段应用函数 frame = DataFrame({'col1':np.random.randn(1000), 'col2':np.random.randn(1000)}) 数据分段,创建分段用的因子 返回每一元素是属于哪一分割区间 factor = pd.cut(frame.col1, 4) 分组计算,然后转成数据框形式 grouped = frame.col2.groupby(factor)grouped.apply(myfunc).unstack()12345678910用分组的均值填充缺失值 自定义函数 fill_mean= lambda x:x.fillna(x.mean()) 分组填充 df.groupby(group_key).apply(fill_mean)12345分组后不同的数据替换不同的值 定义字典 fill_value = {'east':0.5, 'west':-1} 定义函数 fill_func = lambda x:x.fillna(fill_value(x.name)) 分组填充 df.groupby(['index1','index2'...]).apply(fill_func)12345678sql操作 有时候觉得pandas很方便,但是有时候却很麻烦,不如SQL方便。因此pandas中也有一些例子,用pandas实现SQL的功能,简单的就不说了,下面说些复杂点的操作。 之所以说这个复杂的语句,是因为不想将这些数据操作分写在不同的语句中,而是从头到尾连续编码实现一个功能。 SQL复杂操作用到的主要函数是assign,简单说其实和join的功能是一样的,根据df1,df2的索引值来将df2拼接到df1上。 两个函数是query,也听方便的。 有一批销量数据,筛选出那些有2个月以上的销量产品的数据,说白了就是剔除那些新上市产品的数据 方法是先统计每个产品的数据量,然后选出那些数据量>2的产品,再在数据表中选择这些产品 sku smonth a 1 a 2 a 3 a 4 b 5 b 6 b 7 b 8 c 9 c 10 按sku分组,统计smonth的次数,拼接到salecount中,然后查询cnt>2的 salecount.assign(cnt=salecount.groupby(['sku'])['smonth'].count()).query('cnt>2')

xuning715 2019-12-02 01:10:39 0 浏览量 回答数 0

问题

如何使用尽可能简单的方式实现这个SQL语句呢

蛮大人123 2019-12-01 19:51:08 1109 浏览量 回答数 1

回答

使用了koala提供的 createSqlQuery方法 Page<Usertest>pages=getQueryChannelService() . createSqlQuery(sql.toString()).setParameters(conditionVals) .setPage(currentPage,pageSize).pagedList(); 这个例子是没问题的 List<Object[]>obj=getQueryChannelService().createSqlQuery("SELECTksl.ID,ks.`NAME`fromks_resource_lineassignmentkslLEFTJOINks_resourceksONksl.CHILD_ID=ks.IDwhere1=1").list();System.out.println(obj.size()+"==========="); for(Object[]each:obj){ System.out.println(each[0]+"===="); System.out.println(each[1]+"===="); } 引用来自“Koala_考拉”的评论 这个例子是没问题的 List<Object[]>obj=getQueryChannelService().createSqlQuery("SELECTksl.ID,ks.`NAME`fromks_resource_lineassignmentkslLEFTJOINks_resourceksONksl.CHILD_ID=ks.IDwhere1=1").list();System.out.println(obj.size()+"==========="); for(Object[]each:obj){ System.out.println(each[0]+"===="); System.out.println(each[1]+"===="); } hibernateHQL不认得  left join 之类的关键字,无法解析。。改成 selecta.sex,b.namefromXXXa,ZZZZbwherea.id_dept=b.id虽然知道你用左连接。用其他语句实现把. 引用来自“hlevel”的评论 hibernateHQL不认得  left join 之类的关键字,无法解析。。改成 selecta.sex,b.namefromXXXa,ZZZZbwherea.id_dept=b.id虽然知道你用左连接。用其他语句实现把.

爱吃鱼的程序员 2020-06-14 22:39:32 0 浏览量 回答数 0

回答

需要的pom依赖: <groupId>org.apache.flink</groupId> <artifactId>flink-scala_2.11</artifactId> <version>${flink.version}</version> <groupId>org.apache.flink</groupId> <artifactId>flink-table_2.11</artifactId> <version>${flink.version}</version> <groupId>org.apache.flink</groupId> <artifactId>flink-streaming-scala_2.11</artifactId> <version>${flink.version}</version> https://mvnrepository.com/artifact/org.apache.flink/flink-connector-kafka-0.8 --> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-kafka-0.8_2.11</artifactId> <version>${flink.version}</version> 从kafka消费数据,转换为table,然后进行sql查询。用scala开发,需要导入的包,不要漏掉,否则会有问题。 import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment}import org.apache.flink.streaming.api.scala._import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer08import org.apache.flink.streaming.util.serialization.SimpleStringSchemaimport org.apache.flink.table.api.TableEnvironmentimport org.apache.flink.table.api.scala._123456下面是完整代码:package com.ddxygq.bigdata.flink.sql import java.util.Properties import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment}import org.apache.flink.streaming.api.scala._import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer08import org.apache.flink.streaming.util.serialization.SimpleStringSchemaimport org.apache.flink.table.api.TableEnvironmentimport org.apache.flink.table.api.scala._ /** @ Author: keguang @ Date: 2019/2/22 16:13 @ version: v1.0.0 @ description: */ object TableDemo { def main(args: Array[String]): Unit = { demo } def demo2(): Unit ={ val env = ExecutionEnvironment.getExecutionEnvironment val tEnv = TableEnvironment.getTableEnvironment(env) val input:DataSet[WC] = env.fromElements(WC("hello", 1), WC("hello", 1), WC("ciao", 1)) val input2:DataSet[WC] = env.fromElements(WC("hello", 1), WC("hello", 1)) val table = input.toTable(tEnv, 'word, 'frequency) val table2 = input2.toTable(tEnv, 'word2, 'frequency2) val result = table.join(table2).where('word == 'word2).select('word, 'frequency) result.toDataSet[(String, Long)].print() } def demo: Unit ={ val sEnv = StreamExecutionEnvironment.getExecutionEnvironment val sTableEnv = TableEnvironment.getTableEnvironment(sEnv) // 连接kafka val ZOOKEEPER_HOST = "qcloud-test-hadoop01:2181" val KAFKA_BROKERS = "qcloud-test-hadoop01:9092,qcloud-test-hadoop02:9092,qcloud-test-hadoop03:9092" val TRANSACTION_GROUP = "transaction" val kafkaProps = new Properties() kafkaProps.setProperty("zookeeper.connect",ZOOKEEPER_HOST) kafkaProps.setProperty("bootstrap.servers", KAFKA_BROKERS) kafkaProps.setProperty("group.id",TRANSACTION_GROUP) val input = sEnv.addSource( new FlinkKafkaConsumer08[String]("flink-test", new SimpleStringSchema(), kafkaProps) ) .flatMap(x => x.split(" ")) .map(x => (x, 1L)) val table = sTableEnv.registerDataStream("Words", input, 'word, 'frequency) val result = sTableEnv .scan("Words") .groupBy("word") .select('word, 'frequency.sum as 'cnt) sTableEnv.toRetractStream[(String, Long)](result).print() sTableEnv.sqlQuery("select * from Words").toAppendStream[(String, Long)].print() sEnv.execute("TableDemo") }} 这里有两个地方:1、这里举例用了table的算子,和标准的sql查询语法,为了演示table的基本用法。 val result = sTableEnv .scan("Words") .groupBy("word") .select('word, 'frequency.sum as 'cnt) 这个分组聚合统计其实可以替换成: val result = sTableEnv.sqlQuery("select word,sum(frequency) as cnt from Words group by word") // 打印到控制台sTableEnv.toRetractStream(String, Long).print()那么这个与下面的查询结果有什么区别呢? sTableEnv.sqlQuery("select * from Words").toAppendStream[(String, Long)].print() 区别很明显,这里消费kafka的实时数据,那么Words表是一个动态的流表,数据在不断append,一个是group by的分组聚合,结果需要不断更新,比如当前是(hello,4),这时候又来了一个词语hello,就需要update结果为(hello,5),如果有新词,还需要insert,而后者是select * from Words,只是追加结果。 所以,这里只是展示打印到控制台的写法不同,前者调用的是toRetractStream方法,而后者是调用toAppendStream。

小六码奴 2019-12-02 02:02:15 0 浏览量 回答数 0

问题

识别在编写SQL时需要改进VBA代码的区域

心有灵_夕 2019-12-22 13:48:37 0 浏览量 回答数 0

问题

SQL入门50题详解(含知识点讲解及代码运行步骤拆解)

茶什i 2020-01-13 18:03:25 85 浏览量 回答数 1

问题

jfinal oracle分页的问题?报错

爱吃鱼的程序员 2020-06-14 21:32:13 0 浏览量 回答数 1

问题

尝试仅在where条件下定义左联接

心有灵_夕 2019-12-25 21:38:48 0 浏览量 回答数 1

问题

SQL查询语句有哪些?

茶什i 2020-01-16 18:27:02 56 浏览量 回答数 1

问题

如何在存储过程中串联字符串

祖安文状元 2020-01-04 15:32:24 0 浏览量 回答数 1

问题

maxcompute left outer join 不等值On 连接条件查询

猫1984 2019-12-01 20:19:47 1315 浏览量 回答数 1

问题

maxcompute left outer join on条件不支持不等值连接

猫1984 2019-12-01 20:19:48 1315 浏览量 回答数 1

问题

一个业务实现,有关sql查询优化

爵霸 2019-12-01 19:39:51 1535 浏览量 回答数 1

问题

MaxCompute快速入门:运行SQL

行者武松 2019-12-01 22:01:39 1282 浏览量 回答数 0

问题

为什么SQL Server联接执行所需的时间太长?

祖安文状元 2020-01-03 16:12:48 1 浏览量 回答数 1

回答

您要寻找的东西可以通过两个步骤实现: 步骤1:提取每次购买的第一笔交易 根据您的表配置,这可以通过几种不同的方式完成。 如果您的交易ID是连续的,则可以使用以下方法: select * from table a inner join (select purchaseid,min(transactionid) as transactionid from table group by purchaseid) b on a.purchaseid-b.purchaseid and a.transactionid=b.transactionid 如果存在日期变量来驱动交易顺序,则: select a.* from (select *,row_number() over(partition by purchaseid order by date) as rownum from table)a where a.rownum=1 步骤2:合并购买详细信息 如果您使用的是最新版本的SQL Server,则可以使用String_agg函数来完成。如果不是这样,则以下链接突出显示了您可以执行以下操作的几种不同方式: 连接/聚合字符串的最佳方法 希望这可以帮助。

LiuWH 2020-01-03 11:04:10 0 浏览量 回答数 0

问题

sqlsever JDBC问题 : 配置报错 

kun坤 2020-06-04 13:14:56 2 浏览量 回答数 1

问题

LinqToSql在不同的机器上为相同的代码产生不同的SQL查询

保持可爱mmm 2019-12-01 21:59:47 9 浏览量 回答数 1

问题

LM计算引擎 SELECT语法是什么?

nicenelly 2019-12-01 21:25:16 961 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站