MySQL实现大整数相加的udf

最新推荐文章于 2024-05-02 20:39:46 发布
最新推荐文章于 2024-05-02 20:39:46 发布
阅读量1.2k 收藏
点赞数
分类专栏： Linux 文章标签： Ubuntu mysql udf CC++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/corewith/article/details/50964632
版权

前提，大整数保存为varchar, char暂时还不行，还需改进

bigint.h头文件

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

 

#define N 4

 

#ifdef        __cplusplus

extern "C"{

#endif

 

typedef structbigint_node

{

intvalue;                      // four bitsbetween 0000 and 9999

structbigint_node *preview;

structbigint_node *next;

}*BigInt_Node;

 

typedef structbigint_list

{

BigInt_Nodefirst;

intcount;          // the length ofBigInt_Node

//intflag;         // the sign flag, 0represent plus, 1 represent minus.--Have not considered it at present.

}*BigInt_List;

 

BigInt_Listbigint_init();

BigInt_Listbigint_mov(BigInt_List b);

BigInt_Listbigint_mov_value(int value);

BigInt_Liststring_to_list(char *s);

char*list_to_string(BigInt_List list);

BigInt_Listbigint_add(BigInt_List a, BigInt_List b);

 

#ifdef        __cplusplus

}

#endif

bigint.c源代码

#include"bigint.h"

 

/*

bigintinitialization

*/

BigInt_Listbigint_init()

{

BigInt_Listlist=(BigInt_List)(malloc(sizeof(struct bigint_list)));

list->first= NULL;

list->count= 0;

//list->flag= 0;

returnlist;

}

/*

a=b;

*/

BigInt_Listbigint_mov(BigInt_List b)

{

BigInt_Lista=bigint_init();

BigInt_Nodenode = b->first;

inti;

for(i = 0; i < b->count; i++)

{

BigInt_Nodetemp = (BigInt_Node)malloc(sizeof(struct bigint_node));

temp->value= node->value;

if(a->first == NULL)

{

a->first= temp;

temp->preview= temp;

temp->next= temp;

}

else

{

BigInt_Nodelast = a->first->preview;

last->next= temp;

temp->preview= last;

 

temp->next= a->first;

a->first->preview= temp;

}

node= node->next;

}

a->count=b->count;

returna;

}

/*

mova value to list

*/

BigInt_Listbigint_mov_value(int value)

{

BigInt_Listlist=bigint_init();

BigInt_Nodenode = (BigInt_Node)malloc(sizeof(struct bigint_node));

node->value= value;

node->preview= node;

node->next= node;

 

list->count= 1;

list->first= node;

returnlist;

}

/*

 * input: char *s

 * output: BigInt_List

 */

BigInt_Liststring_to_list(char *s)

{

BigInt_Listlist=bigint_init();

inti,k=N-1,len=strlen(s);

charstr[N+1];

for(i=len-1;i>=-1;i--)

{

if(k==-1)

{

BigInt_Nodenode=(BigInt_Node)malloc(sizeof(struct bigint_node));

node->value=atoi(str);

if(list->first==NULL)

{

list->first=node;

node->preview=node;

node->next=node;

}

else

{

list->first->preview->next=node;

node->preview=list->first->preview;

 

node->next=list->first;

list->first->preview=node;

 

list->first=node;

}

list->count++;

if(i==-1)break; // end

k=N-1;

}

if(i<k){k=i; str[k+1]='\0';}

str[k--]=s[i];

}

returnlist;

}

/*

input:BigInt_List

output:char *

*/

char*list_to_string(BigInt_List list)

{

char*s=(char *)malloc(256);

inti,j,k=0;

BigInt_Nodenode=list->first;

for(i=0;i<list->count;i++)

{

charstr[N+1];

sprintf(str,"%d",node->value);

intlen=strlen(str);

//if the length is less N(=4) bits, then supplement enough by '0', and do notconsider the first one for it's MSB.

if(i!=0&& len<N)

{

charstr_temp[N+1];

intt=0;

for(j=0;j<N;j++)

{

if(j<N-len)        str_temp[j]='0';

elsestr_temp[j]=str[t++];

}

for(j=0;j<N;j++)str[j]=str_temp[j];

len=strlen(str);

}

for(j=0;j<len;j++)

{

s[k++]=str[j];

}

node=node->next;

}

s[k]='\0';

returns;

}

/*

 * c=a+b

 */

BigInt_Listbigint_add(BigInt_List a, BigInt_List b)

{

inti, carry = 0;

BigInt_Listc=bigint_mov(a);

//from end to begin

BigInt_Nodenode_a = c->first->preview;

BigInt_Nodenode_b = b->first->preview;

for(i = 0; i < c->count && i < b->count; i++)

{

intvalue=node_a->value + node_b->value + carry;

if(value<10000)carry=0;

else

{

value-=10000;

carry=1;

}

node_a->value=value;

node_a= node_a->preview;

node_b= node_b->preview;

}

//if c(also a) has more

while(i < c->count && carry>0)

{

intvalue = node_a->value + carry;

if(value < 10000) carry = 0;

else

{

value-=10000;

carry= 1;

}

node_a->value=value;

node_a= node_a->preview;

i++;

}

//if b has more

while(i < b->count)

{

intvalue = node_b->value + carry;

if(value < 10000) carry = 0;

else

{

value-= 10000;

carry= 1;

}

BigInt_Nodenode=(BigInt_Node)malloc(sizeof(struct bigint_node));

node->value=value;

 

c->first->preview->next=node;

node->preview=c->first->preview;

 

node->next=c->first;

c->first->preview=node;

 

c->first=node;

c->count++;

 

node_b= node_b->preview;

i++;

}

if(carry == 1)

{

BigInt_Nodenode = (BigInt_Node)malloc(sizeof(struct bigint_node));

node->value= carry;

 

c->first->preview->next= node;

node->preview= c->first->preview;

 

node->next= c->first;

c->first->preview= node;

 

c->first= node;

c->count++;

}

if(c->count > 1)

{

while(c->first->value == 0)

{

c->first->preview->next= c->first->next;

c->first->next->preview= c->first->preview;

 

c->first= c->first->next;

c->count--;

if(c->count == 1)

{

break;

}

}

}

returnc;

}

编译成动态库g++ -shared -fPIC -o libbigint.so bigint.c

将生成的.so文件放入/usr/lib目录下

udf文件udf_sum_samp.cc

#define DEBUG 1

 

#include<memory>

 

#include<string.h>

#include<stdint.h>

#include<iostream>

#include<bigint.h>

 

 

extern "C"{

 

typedef unsignedlong long ulonglong;

typedef long longlonglong;

// Use the standardmysql dev headers.

#include<mysql.h>

#include<ctype.h>

 

my_bool   udf_sum_samp_init(UDF_INIT *const initid,UDF_ARGS *const args,

                           char *constmessage);

void      udf_sum_samp_deinit(UDF_INIT *constinitid);

void      udf_sum_samp_clear(UDF_INIT *constinitid, char *const is_null,

                            char *const error);

my_bool   udf_sum_samp_add(UDF_INIT *const initid,UDF_ARGS *const args,

                          char *const is_null,char *const error);

char *    udf_sum_samp(UDF_INIT *const initid,UDF_ARGS *const args,

                      char *const result,unsigned long *const length,

                      char *const is_null, char*const error);

 

} /* extern"C" */

 

struct agg_state {

    BigInt_List sum;

    void *rbuf;

};

 

my_bool

udf_sum_samp_init(UDF_INIT*const initid, UDF_ARGS *const args,

                 char *const message)

{

    if (args->arg_count != 1 ||

        args->arg_type[0] != STRING_RESULT)

    {

        strcpy(message, "Usage:udf_sum_samp(string value)");

        return 1;

    }

 

    agg_state *const as = new agg_state();

    as->rbuf = malloc(256);

    initid->ptr = reinterpret_cast<char*>(as);

    initid->maybe_null = 1;

    return 0;

}

 

void

udf_sum_samp_deinit(UDF_INIT*const initid)

{

    agg_state *const as =reinterpret_cast<agg_state *>(initid->ptr);

    free(as->rbuf);

    delete as;

}

 

void

udf_sum_samp_clear(UDF_INIT*const initid, char *const is_null, char *const error)

{

    agg_state *const as =reinterpret_cast<agg_state *>(initid->ptr);

    as->sum = bigint_mov_value(0);

}

 

my_bool

udf_sum_samp_add(UDF_INIT*const initid, UDF_ARGS *const args,

                char *const is_null, char*const error)

{

    agg_state *const as =reinterpret_cast<agg_state *>(initid->ptr);  

    //

    BigInt_List e;

    if (NULL == args->args[0]) {

        e = bigint_mov_value(0);

    } else {

        e = string_to_list(args->args[0]);

    }

    //std::cerr << "the value ofargs " << args->args[0] << "\n";

    //std::cerr << "the value oflist_to_string " << list_to_string(e) << "\n";

    as->sum=bigint_add(as->sum,e);

    //std::cerr << "sum so far" << as->sum << "\n";

   memset(args->args[0],0,strlen(args->args[0]));

    return true;

}

 

char *

udf_sum_samp(UDF_INIT*const initid, UDF_ARGS *const args, char *const result,

            unsigned long *const length, char*const is_null, char *const error)

{

    agg_state *const as =reinterpret_cast<agg_state *>(initid->ptr);

    strcpy(static_cast<char*>(as->rbuf),list_to_string(as->sum));

    //std::cerr << "the result:" << static_cast<char *>(as->rbuf) << "\n";

    strcpy(result,static_cast<char*>(as->rbuf));

    *length=strlen(result);

    return static_cast<char*>(as->rbuf);

}

将udf文件编译成动态库 g++ -shared -fPIC -I /usr/include/mysql/ udf_sum_samp.cc-o udf_sum_samp.so -lbigint

将生成的.so放入mysql/plugin下，sudo cp udf_sum_samp.so/usr/lib/mysql/plugin

进入mysql，mysql -u root -p

  • 创建数据库 create database test;
  • 使用该数据库 use test;
  • 创建表 ---flag暂时还没用上
    • create table bigint_demo_char(id int primary key auto_increment, value char(20), flag int);
    •  create table bigint_demo_varchar(id int primary key auto_increment, value varchar(20), flag int);
  • 插入测试数据
    • insert into bigint_demo_char(value,flag) values('34',0)
    • insert into bigint_demo_char(value,flag) values('5',0)
    • insert into bigint_demo_char(value,flag) values('1',0)
    • insert into bigint_demo_char(value,flag) values('225',0)
    • insert into bigint_demo_varchar(value,flag) values('34',0)
    • insert into bigint_demo_varchar(value,flag) values('5',0)
    • insert into bigint_demo_varchar(value,flag) values('1',0)
    • insert into bigint_demo_varchar(value,flag) values('225',0)
  • 创建udf
  • create aggregate function soname udf_sum_samp returns string soname 'udf_sum_samp.so';
  • 使用该udf
    • select udf_sum_samp(value) from bigint_demo_varchar;

计算机生成了可选文字:mysql> select from btgtnt_demo_varchar; 1 udf 265 row in set (0.00 sec)

  • select udf_sum_samp(value) from bigint_demo_char;

计算机生成了可选文字:mysql> select from btgtnt_demo_char; 1 row in set (0.00 sec)

udf代码中注释掉输出语句，可以把一些结果输出到mysql的错误日志中，默认是在/var/log/error.log

计算机生成了可选文字:the the the the the the the the the the the the the the the the the the value value value value value value value value of of of of of of of of args args args args result: 265 value of args value of list value of args value of list value of args value of list value of args value of list result: 34 34 5 1 225 225 34 _to_strtng 34eeeeeeeeeeeeeeee 5 _to_strtng seeeeeeeeeeeeeeee 1 _to_strtng leeeeeeeeeeeeeeee 225 to string 2250000000000000000

corewith
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MYSQL_UDF-5.0.rar_mysql udf_udf_udf mysql
09-23
udf mysql c语言代码，欢迎大家使用
MYSQL bigint 加法运算后结果显示为科学计数的问题
meishishaishai的博客
08-20 1273
问题描述： 最近做一个功能，实现对MYSQL数据库表数据进行同表复制插入操作，在将拷贝后的数据插入原表时，为了避免主键冲突，需要对其主键进行处理（目前是取原表最大id+伪造了一个rownum进行处理），原始主键是bigint类型的，进行运算之后变成了科学计数法，如下： SELECT (select max(id) from test) + (@rownum:=@rownum+1) id from (SELECT @rownum:=0) r,test where tenant_id =10000 图片中可
BigIn——超大型整数的实现——链表法
weixin_45888136的博客
05-29 550
环境：Qt，写的冗长，初学阶段，待提升。。。
大数运算
ly402609921的专栏
08-04 849
說明 基於記憶體的有效運用，程式語言中規定了各種不同的資料型態，也因此變數所可以表達的最大整數受到限制，例如123456789123456789這樣的 整數就不可能儲存在long變數中（例如C/C++等），我們稱這為long數，這邊翻為超長整數（避免與資料型態的長整數翻譯混淆），或俗稱大數運算。解法 一個變數無法表示超長整數，則就使用多個變數，當然這使用陣列最為方便，假設程式語言的最大資料型態可以儲存至65535的數好了，為了計算方便及符合使用十進位制的習慣，讓每一個陣列元素可以儲存四個位數，也就
bigInt数据类型 很长的整数相加
Wancc123的博客
10-21 487
简述 BigInt数据类型提供了一种方法来表示大于2^53-1的整数。BigInt可以表示任意大的整数 BigInt构造函数 传递给BigInt()的参数将自动转换为BigInt: // 参数只能是整数 整数字符串 布尔值 其他会报错 BigInt('2'); // → 2n BigInt(2); // → 2n BigInt(true); // → 1n BigInt(false); // → 0n 相加： BigInt(2)+1； // 报错 BigInt(2)+1n; // 3n BigInt
[C++]第七次作业：实现一个大整数类BigInt
毛佳茗de代码
01-22 4625
/*作业七1. 不同计算机系统中所能表示的证书的范围不同。如在一个32位的机器上，一个long类型的整数范围是-231~231-1。在某些应用中，需要处理比这个范围大得多的整数。不同的大整数的长度（数字位数）可能差别较大，请基于STL库中的list容器（双向链表）实现一个大整数类BigInt.*/#include "BigInt.h"void main(){ BigInt a = "993
基于golang实现的http_udf(mysql)
08-27
基于golang实现的mysql udf，其功能实现在于可以直接通过mysql进行get、post请求
mysql-udf-http.c
07-01
mysql-udf-http.c编译此文件之后可使用MySQL中http_post或http_get方法，此处为原文件，需要自行编译，请谨慎下载。备注：如发现此文件编译时缺少文件可自行下载
mysql_reverse_udf.zip
08-02
mysql反弹端口提权利用dll文件。
lib_mysqludf_sys
12-22
mysql 系统命令udf，各种平台64位包
bigint:适用于C和C ++的任意精度整数库
05-02
停产，转而使用 比金特 C用法示例： # include " bigint.h " # include < stdio> int main (){ char buf[ 65536 ]; /* neat trick to avoid having to write &a, &b, &c everywhere */ bigint a[ 1 ], b[ 1 ], c[ 1 ]; /* bigints have to be initialized (same as memset'ed to zero) */ bigint_init (a); bigint_init (b); bigint_init (c); /* create bigint from string */ bigint_from_str (a, " 12
C++有符号大整数类型bigint
03-23
自定义的C++有符号大整数类型bigint
mysql 查询最大值的总和_mysql中最大值和最小值以及总和查询与计数查询的实例详解...
weixin_33205138的博客
01-19 1800
1、最大值查询：mysql> select max(score) from 4a;+------------+| max(score) |+------------+| 93 |+------------+1 row in set (0.06 sec)2、最小值查询：mysql> select max(4a.score),min(4inall.score) from 4...
mysql聚合函数求和
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
11-17 2013
mysql查询需要多次使用聚合函数值 (selectcount(*)fromtableA)-(selectmaxfromtableBwheretableB.username=tableA.uername) 难道不能利用之前的临时值吗，一定要重新算一遍吗 本回答由网友推荐 MySQL中，使用聚合函数+for up...
mysql bigint 运算_mysql中int、bigint、smallint 和 tinyint的区别详细介绍
weixin_42520025的博客
01-19 587
最近使用mysql数据库的时候遇到了多种数字的类型，主要有int,bigint,smallint和tinyint。其中比较迷惑的是int和smallint的差别。今天就在网上仔细找了找，找到如下内容，留档做个总结：使用整数数据的精确数字数据类型。bigint从 -2^63 (-9223372036854775808) 到 2^63-1 (9223372036854775807) 的整型数据(所有数...
python 存入数据库bigint_python基础_MySQL的bigint类型
weixin_39798943的博客
01-15 348
bigint支持的数字的大小范围为：19位，存电话号码。有符号范围：-9223372036854775808 到 9223372036854775807int支持的数字范围为：10位，有符号范围：-2147483648 到 2147483647 无符号范围：0-4294967295mysql> create table c5(id bigint);Query OK, 0 rows aff...
codeblocks如何让输出结果 空格_简单讲讲如何实现两个正整数相加，然后输出这个结果...
weixin_39850981的博客
11-24 725
首先吧，两个整数123 456，相加得到579，我们就得输出579，这个很容易操作，但是如果是：1212161596156198115645646886148461554+2671232162176217624372497590415915915029125 呢？long ? long long ? long long long?...没这个类型。这数据大小没办法以单个变量储存。当...
MySql中深度分页的问题
最新发布
m0_68723562的博客
05-02 611
MySql深度分页的问题，就是比如我们需要所查询出的表数据量较大，需要进行查询结果返回集的后面部分，所出现的性能问题。比如说我们有一个一百万数据量的表，我们分页需要查询99990,10，数据库通常情况下会先扫描前99990条数据， 再进行分页返回最后10条，这样就会导致查询接口性能变慢，随着OFFSET值的增大，查询性能会显著下降。这是因为MySQL需要扫描从第一条记录到OFFSET指定的位置，然后返回LIMIT数量的结果，这在大数据集中会导致大量的磁盘I/O操作和较慢的查询响应时间。
MySQL —— 表的基本操作
学习C++的小陈同学
04-30 548
本篇整理了和表结构相关的各种基本操作（增删查改等等）
mysql5.764位udf提权
04-03
很抱歉，但我不能提供关于MySQL 5.7 64位UDF提权的信息。MySQL是一个开源的关系型数据库管理系统，UDF（User-Defined Function）是用户自定义函数的缩写，用于扩展MySQL的功能。但是，UDF提权是一种安全漏洞利用技术...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值