精华内容
下载资源
问答
  • 创建带参数的更新查询
    千次阅读
    2019-05-28 22:59:00

    创建带输入参数的存储过程

    语法

    create proc[edure] 存储过程名

      @参数1 数据类型=默认值,

      ……

      @参数n 数据类型=默认值

     

    as

      sql语句

    go     --必须要加批处理的go

    例子:

     1 --创建带输入参数的存储过程
     2 /*
     3     题目:查询指定的用户在指定的时间段内的下单信息,
     4     如果结束日期没有指的话,那么查询的是到今天为止的下单信息
     5 */
     6 use E_Market
     7 go 
     8 if exists (select * from sysobjects where name='usp_GetOrderInfo')
     9 drop proc usp_GetOrderInfo
    10 go
    11 create proc usp_GetOrderInfo
    12     @startDate datetime,   --开始时间
    13     @endDate datetime=null,   --结束时间
    14     @userId varchar(20)=null  --指定的用户
    15 as
    16     if @endDate is null    --判断结束日期是否为空
    17         begin
    18             set @endDate=GETDATE()   --赋值当前日期
    19         end
    20 
    21     if @userId is null  --查询指定时间段内的所有订单信息
    22         begin
    23             select O.UserId as 用户号, PayWay as 付款方式, O.Amount as 购买数量,C.CommodityName as 商品名称,
    24                 S.SortName as 类别名称, O.OrderTime as 下单时间 from OrderInfo as O 
    25                  inner join CommodityInfo as C on O.CommodityId=C.CommodityId
    26                  inner join CommoditySort as S on C.SortId=S.SortId
    27                     where  O.OrderTime between @startDate and @endDate
    28         end
    29 
    30     else  --查询指定用户指定时间段内的所有订单信息
    31         begin 
    32             select O.UserId as 用户号, PayWay as 付款方式, O.Amount as 购买数量,C.CommodityName as 商品名称,
    33             S.SortName as 类别名称, O.OrderTime as 下单时间 from OrderInfo as O 
    34              inner join CommodityInfo as C on O.CommodityId=C.CommodityId
    35              inner join CommoditySort as S on C.SortId=S.SortId
    36              where O.UserId=@userId and O.OrderTime between @startDate and @endDate
    37         end
    38 go
    39 
    40 --如何使用带参数的存储过程
    41 --1)结束日期与用户都使用默认值
    42 --只指定了开始时间,查询的是从开始时间到今天的所有订单信息
    43 exec usp_GetOrderInfo '2014-11-1'
    44 
    45 --2)结束日期不为空,从开始时间到结束时间的所有订单信息
    46 --隐式调用,参数的顺序必须与创建存储过程的参数顺序完全相同
    47 exec usp_GetOrderInfo '2014-11-1', '2014-11-12','xiangxiang'
    48 
    49 --3)显示调用
    50 --显示调用对参数顺序无要求,如果参数中一个写"@名称=值"的形式,之后的参数都必须写成"@名称=值"的形式,默认值可以使用default代替
    51 exec usp_GetOrderInfo @UserId='xiangxiang',@startDate='2014-11-1',@endDate=default
    52 
    53 
    54 --4)可以通过声明变量来调用
    55 declare @d1 datetime,@d2 datetime, @uid varchar(20)
    56 set @d1='2014-11-1'
    57 set @d2='2014-12-1'
    58 set @uid='xiangxiang'
    59 exec usp_GetOrderInfo @d1,@d2,@uid
    60 --除了显示调用外,要求参数位置必须与存储过程定义时顺序相同

     

    转载于:https://www.cnblogs.com/zhangxudong-cnblogs/p/10940966.html

    更多相关内容
  • 创建或者更新文档时,会对文档进行分词 2,Search time analysis. 查询时,对查询语句分词 指定查询时使用哪个分词器的方式有:  - 查询时通过analyzer指定分词器 GET test_index/_search { "query": { ...

    analyzer  

    分词器使用的两个情形:  
    1,Index time analysis.  创建或者更新文档时,会对文档进行分词
    2,Search time analysis.  查询时,对查询语句分词

     

    - 查询时通过analyzer指定分词器

    POST test_index/_search
    {
      "query": {
        "match": {
          "name": {
            "query": "lin",
            "analyzer": "standard"
          }
        }
      }
    }

    - 创建index mapping时指定search_analyzer

    PUT test_index
    {
      "mappings": {
        "doc": {
          "properties": {
            "title":{
              "type": "text",
              "analyzer": "whitespace",
              "search_analyzer": "standard"
            }
          }
        }
      }
    }

    索引时分词是通过配置 Index mapping中的每个字段的参数analyzer指定的

    不指定分词时,会使用默认的standard分词器

    注意:

     明确字段是否需要分词,不需要分词的字段将type设置为keyword,可以节省空间和提高写性能。

    _analyzer api    

    POST _analyze
    {
        "analyzer": "standard",
        "text": "this is a test"
    }
    # 可以查看text的内容使用standard分词后的结果
    
    {
    "tokens": 
        [
            {
                "token": "this",
                "start_offset": 0,
                "end_offset": 4,
                "type": "<ALPHANUM>",
                "position": 0
            },
            {
                "token": "is",
                "start_offset": 5,
                "end_offset": 7,
                "type": "<ALPHANUM>",
                "position": 1
            },
            {
                "token": "a",
                "start_offset": 8,
                "end_offset": 9,
                "type": "<ALPHANUM>",
                "position": 2
            },
            {
                "token": "test",
                "start_offset": 10,
                "end_offset": 14,
                "type": "<ALPHANUM>",
                "position": 3
            }
        ]
    }
    

     

    设置analyzer

    PUT test
    {
        "settings": {
            "analysis": { #自定义分词器
                "analyzer": { # 关键字
                    "my_analyzer":{ # 自定义的分词器
                        "type":"standard", #分词器类型standard
                        "stopwords":"_english_" #standard分词器的参数,默认的stopwords是\_none_
                    }
                }
            }
        },
        "mappings": {
            "doc":{
                "properties": {
                    "my_text":{
                        "type": "text",
                        "analyzer": "standard", # my_text字段使用standard分词器
                        "fields": {
                            "english":{ # my_text.english字段使用上面自定义的my_analyzer分词器
                                "type": "text",
                                "analyzer": "my_analyzer"
                            }
                        }
                    }
                }
            }
        }
    }
    
    POST test/_analyze
    {
        "field": "my_text", # my_text字段使用的是standard分词器
        "text": ["The test message."]
    }
    
    -------------->[the,test,message]
    
    POST test/_analyze
    {
        "field": "my_text.english", #my_text.english使用的是my_analyzer分词器
        "text": ["The test message."]
    }
    
    ------------>[test,message]
    

    ES内置了很多种analyzer。比如:

    • standard  由以下组成
      • tokenizer:Standard Tokenizer

    token filter:Standard Token Filter,Lower Case Token Filter,Stop Token Filter 

    analyzer API测试 :
    POST _analyze
    {
      "analyzer": "standard",
      "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
    }

    得到结果:

    {
      "tokens": [
        {
          "token": "the",
          "start_offset": 0,
          "end_offset": 3,
          "type": "<ALPHANUM>",
          "position": 0
        },
        {
          "token": "2",
          "start_offset": 4,
          "end_offset": 5,
          "type": "<NUM>",
          "position": 1
        },
        {
          "token": "quick",
          "start_offset": 6,
          "end_offset": 11,
          "type": "<ALPHANUM>",
          "position": 2
        },
        {
          "token": "brown",
          "start_offset": 12,
          "end_offset": 17,
          "type": "<ALPHANUM>",
          "position": 3
        },
        {
          "token": "foxes",
          "start_offset": 18,
          "end_offset": 23,
          "type": "<ALPHANUM>",
          "position": 4
        },
        {
          "token": "jumped",
          "start_offset": 24,
          "end_offset": 30,
          "type": "<ALPHANUM>",
          "position": 5
        },
        {
          "token": "over",
          "start_offset": 31,
          "end_offset": 35,
          "type": "<ALPHANUM>",
          "position": 6
        },
        {
          "token": "the",
          "start_offset": 36,
          "end_offset": 39,
          "type": "<ALPHANUM>",
          "position": 7
        },
        {
          "token": "lazy",
          "start_offset": 40,
          "end_offset": 44,
          "type": "<ALPHANUM>",
          "position": 8
        },
        {
          "token": "dog's",
          "start_offset": 45,
          "end_offset": 50,
          "type": "<ALPHANUM>",
          "position": 9
        },
        {
          "token": "bone",
          "start_offset": 51,
          "end_offset": 55,
          "type": "<ALPHANUM>",
          "position": 10
        }
      ]
    }

    whitespace  空格为分隔符

    POST _analyze
    {
      "analyzer": "whitespace",
      "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
    }
    -->  [ The,2,QUICK,Brown-Foxes,jumped,over,the,lazy,dog's,bone. ]

    simple

    POST _analyze
    {
      "analyzer": "simple",
      "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
    }
    ---> [ the, quick, brown, foxes, jumped, over, the, lazy, dog, s, bone ]
    
    

    stop   默认stopwords用_english_ 

    POST _analyze
    {
        "analyzer": "stop",
        "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
    }
    
    -->[ quick, brown, foxes, jumped, over, lazy, dog, s, bone ]
    
    可选参数:
    # stopwords
    # stopwords_path

    keyword  不分词的

    POST _analyze
    {
      "analyzer": "keyword",
      "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."]
    }
    得到  "token": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone." 一条完整的语句

     

    第三方analyzer插件---中文分词(ik分词器)

    es内置很多分词器,但是对中文分词并不友好,例如使用standard分词器对一句中文话进行分词,会分成一个字一个字的。这时可以使用第三方的Analyzer插件,比如 ik、pinyin等。这里以ik为例

    1,首先安装插件,重启es:

    # bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.3.0/elasticsearch-analysis-ik-6.3.0.zip
    # /etc/init.d/elasticsearch restart

    2,使用示例:

    GET _analyze
    {
      "analyzer": "ik_max_word",
      "text": "你好吗?我有一句话要对你说呀。"
    }
    
    
    得到:
    {
    "tokens": [
    {
    "token": "你好",
    "start_offset": 0,
    "end_offset": 2,
    "type": "CN_WORD",
    "position": 0
    },
    {
    "token": "好吗",
    "start_offset": 1,
    "end_offset": 3,
    "type": "CN_WORD",
    "position": 1
    },
    {
    "token": "我",
    "start_offset": 4,
    "end_offset": 5,
    "type": "CN_CHAR",
    "position": 2
    },
    {
    "token": "有",
    "start_offset": 5,
    "end_offset": 6,
    "type": "CN_CHAR",
    "position": 3
    },
    {
    "token": "一句话",
    "start_offset": 6,
    "end_offset": 9,
    "type": "CN_WORD",
    "position": 4
    },
    {
    "token": "一句",
    "start_offset": 6,
    "end_offset": 8,
    "type": "CN_WORD",
    "position": 5
    },
    {
    "token": "一",
    "start_offset": 6,
    "end_offset": 7,
    "type": "TYPE_CNUM",
    "position": 6
    },
    {
    "token": "句话",
    "start_offset": 7,
    "end_offset": 9,
    "type": "CN_WORD",
    "position": 7
    },
    {
    "token": "句",
    "start_offset": 7,
    "end_offset": 8,
    "type": "COUNT",
    "position": 8
    },
    {
    "token": "话",
    "start_offset": 8,
    "end_offset": 9,
    "type": "CN_CHAR",
    "position": 9
    },
    {
    "token": "要对",
    "start_offset": 9,
    "end_offset": 11,
    "type": "CN_WORD",
    "position": 10
    },
    {
    "token": "你",
    "start_offset": 11,
    "end_offset": 12,
    "type": "CN_CHAR",
    "position": 11
    },
    {
    "token": "说呀",
    "start_offset": 12,
    "end_offset": 14,
    "type": "CN_WORD",
    "position": 12
    }
    ]
    }

    参考:https://github.com/medcl/elasticsearch-analysis-ik

     

     

    还可以用内置的 character filter, tokenizer, token filter 组装一个analyzer(custom analyzer)

    custom  定制analyzer,由以下几部分组成

    • 0个或多个character filters
    • 1个tokenizer
    • 0个或多个 token filters
    PUT t_index
    {
      "settings": {
        "analysis": {
          "analyzer": {
            "my_analyzer":{
              "type":"custom",
              "tokenizer":"standard",
              "char_filter":["html_strip"],
              "filter":["lowercase"]
            }
          }
        }
      }
    }
    
    POST t_index/_analyze
    {
      "analyzer": "my_analyzer",
      "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's <b> bone.</b>"]
    }
    
    得到:[the,2,quick,brown,foxes,jumped,over,the,lazy,dog's,bone]

    自定义分词器

    自定义分词需要在索引的配置中设定,如下所示:

    PUT test_index
    {
        "settings": {
            "analysis": { # 分词设置,可以自定义
                "char_filter": {}, #char_filter 关键字
                "tokenizer": {}, #tokenizer 关键字
                "filter": {}, #filter 关键字
                "analyzer": {} #analyzer 关键字
            }
        }
    }
    

    character filter  在tokenizer之前对原始文本进行处理,比如增加,删除,替换字符等

    会影响后续tokenizer解析的position和offset信息

    html strip  除去html标签和转换html实体

    • 参数:escaped_tags不删除的标签
    POST _analyze
    {
      "tokenizer": "keyword",
      "char_filter": ["html_strip"],
      "text": ["<p>I&apos;m so <b>happy</b>!</p>"]
    }
    
    得到:
          "token": """
    
    I'm so happy!
    
    """
    
    #配置示例
    PUT t_index
    {
      "settings": {
        "analysis": {
          "analyzer": {  #关键字
            "my_analyzer":{   #自定义analyzer
              "tokenizer":"keyword",
              "char_filter":["my_char_filter"]
            }
          },
          "char_filter": {  #关键字
            "my_char_filter":{   #自定义char_filter
              "type":"html_strip",
              "escaped_tags":["b"]  #不从文本中删除的HTML标记数组
            }
          }
        }
      }
    }
    
    POST t_index/_analyze
    {
      "analyzer": "my_analyzer",
      "text": ["<p>I&apos;m so <b>happy</b>!</p>"]
    }
    
    
    得到:
          "token": """
    
    I'm so <b>happy</b>!
    
    """,

    mapping    映射类型,以下参数必须二选一

    • mappings 指定一组映射,每个映射格式为 key=>value
    • mappings_path 绝对路径或者相对于config路径   key=>value
    PUT t_index
    {
        "settings": {
            "analysis": {
                "analyzer": { #关键字
                    "my_analyzer":{ #自定义分词器
                            "tokenizer":"standard",
                            "char_filter":"my_char_filter"
                        }
                },
                "char_filter": { #关键字
                    "my_char_filter":{  #自定义char_filter
                        "type":"mapping",
                        "mappings":[ #指明映射关系
                        ":)=>happy",
                        ":(=>sad"
                        ]
                    }
                }
            }
        }
    }
    
    POST t_index/_analyze
    {
        "analyzer": "my_analyzer",
        "text": ["i am so :)"]
    }
    
    
    得到 [i,am,so,happy]
    

    pattern replace

    • pattern参数  正则
    • replacement 替换字符串 可以使用$1..$9
    • flags  正则标志

    tokenizer  将原始文档按照一定规则切分为单词

    • standard
      • 参数:max_token_length,最大token长度,默认是255
    PUT t_index
    {
        "settings": {
            "analysis": {
                "analyzer": {
                    "my_analyzer":{
                        "tokenizer":"my_tokenizer"
                    }
                },
                "tokenizer": {
                    "my_tokenizer":{
                            "type":"standard",
                            "max_token_length":5
                    }
                }
            }
        }
    }
    
    POST t_index/_analyze
    {
        "analyzer": "my_analyzer",
        "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."]
    }
    
    得到 [ The, 2, QUICK, Brown, Foxes, jumpe, d, over, the, lazy, dog's, bone ]
    # jumped 长度为6 在5这个位置被分割
    

    letter    非字母时分成多个terms

    POST _analyze
    {
      "tokenizer": "letter",
      "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."]
    }
    
    得到 [ The, QUICK, Brown, Foxes, jumped, over, the, lazy, dog, s, bone ]

    lowcase  跟letter tokenizer一样 ,同时将字母转化成小写

    POST _analyze
    {
      "tokenizer": "lowercase",
      "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
    }
    
    得到  [ the, quick, brown, foxes, jumped, over, the, lazy, dog, s, bone ]

    whitespace   按照空白字符分成多个terms

    • 参数:max_token_length
    POST _analyze
    {
        "tokenizer": "whitespace",
        "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
    }
     
    得到 [ The, 2, QUICK, Brown-Foxes, jumped, over, the, lazy, dog's, bone. ]

    keyword   空操作,输出完全相同的文本

    • 参数:buffer_size,单词一个term读入缓冲区的长度,默认256
    POST _analyze
    {
        "tokenizer": "keyword",
        "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."]
    }
    
    得到"token": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone." 一个完整的文本

    token filter   针对tokenizer 输出的单词进行增删改等操作

    lowercase  将输出的单词转化成小写

    POST _analyze
    {
        "filter": ["lowercase"],
        "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone"]
    }
    --->
    "token": "the 2 quick brown-foxes jumped over the lazy dog's bone"
    
    PUT t_index
    {
        "settings": {
            "analysis": {
                "analyzer": {
                    "my_analyzer":{
                        "type":"custom",
                        "tokenizer":"standard",
                        "filter":"lowercase"
                    }
                }
            }
        }
    }
    
    POST t_index/_analyze
    {
      "analyzer": "my_analyzer",
        "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone"]
    }

    stop  从token流中删除stop words 。

    参数有:

    # stopwords   要使用的stopwords, 默认_english_
    # stopwords_path
    # ignore_case   设置为true则为小写,默认false
    # remove_trailing
    PUT t_index
    {
      "settings": {
        "analysis": {
          "analyzer": {
            "my_analyzer":{
              "type":"custom",
              "tokenizer":"standard",
              "filter":"my_filter"
            }
          },
          "filter": {
            "my_filter":{
              "type":"stop",
              "stopwords":["and","or","not"]
            }
          }
        }
      }
    }
    
    POST t_index/_analyze
    {
      "analyzer": "my_analyzer",
      "text": ["lucky and happy not sad"]
    }
    
    -------------->
    [lucky,happy,sad]
    

     

    展开全文
  • mysql 创建带输入参数的函数

    千次阅读 2014-08-15 16:02:17
    '判断暂存货箱是否可以用来下架用(0:不可以用来下架,1:可以用来下架,直接插入容器表2:可以,更新容器)' BEGIN DECLARE v_countGC int ; DECLARE v_GCCountHold int ; DECLARE v_GCIDHold int...

    代码部分:

    CREATE DEFINER=`root`@`%` FUNCTION `useableBox`(`p_CBidHold` VARCHAR(50), `p_skuID` INT, `r_GCCountHold` INT, `r_GCIDHold` INT)
    RETURNS int(11)
    LANGUAGE SQL
    NOT DETERMINISTIC
    CONTAINS SQL
    SQL SECURITY DEFINER
    COMMENT '判断暂存货箱是否可以用来下架用(0:不可以用来下架,1:可以用来下架,直接插入容器表2:可以,更新容器)'
    BEGIN
    DECLARE v_countGC int;
    DECLARE v_GCCountHold int;
    DECLARE v_GCIDHold int;
    DECLARE v_skuIDHold int;
    DECLARE v_useableBox int;
    DECLARE v_onPlace varchar(50);
    select count(GCID),skuID,onPlace,GCCount,GCID into v_countGC,v_skuIDHold,v_onPlace,v_GCCountHold,v_GCIDHold from globalContainer
    where CBid = p_CBidHold;
    set r_GCCountHold = v_GCCountHold;
    set r_GCIDHold = v_GCIDHold;
    if v_countGC!=0 then
    if v_onPlace = '' or v_onPlace is null then
    if p_skuID = v_skuIDHold then
    set v_useableBox = 2;
    else
    set v_useableBox = 1;
    end if;
    else
    set v_useableBox = 0;
    end if;
    else
    set v_useableBox = 1;
    end if;
    return v_useableBox;
    END
    
    
    在工具中截图效果:
    
    mysql <wbr>创建带输入参数的函数

    mysql <wbr>创建带输入参数的函数

    展开全文
  • 本文对数据库的建立、更新,数据的插入、更新查询、删除,及事务的处理进行示例讲解。 代码里有注释帮助理解。 实现代码: activity_main.xml <?xml version="1.0" encoding="utf-8"?> <...

    运行效果:

    本文对数据库的建立、更新,数据的插入、更新、查询、删除,及事务的处理进行示例讲解。

    代码里有注释帮助理解。

    实现代码:

    activity_main.xml

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/activity_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context="com.example.administrator.dbexcise.MainActivity">
    
        <Button
            android:id="@+id/bt1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Create DB"
            android:textAllCaps="false"
            android:onClick="testCreateDB"/>
    
        <Button
            android:id="@+id/bt2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Insert Date"
            android:textAllCaps="false"
            android:onClick="testInsertDate"/>
    
        <Button
            android:id="@+id/bt3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Delete Date"
            android:textAllCaps="false"
            android:onClick="testDeleteDate"/>
    
        <Button
            android:id="@+id/bt4"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Update Date"
            android:textAllCaps="false"
            android:onClick="testUpdateDate"/>
    
        <Button
            android:id="@+id/bt5"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Query Date"
            android:textAllCaps="false"
            android:onClick="testQueryDate"/>
    
        <Button
            android:id="@+id/bt6"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Handle affair"
            android:textAllCaps="false"
            android:onClick="testHandleAffair"/>
    </LinearLayout>
    

    DBHelper

    package com.example.administrator.dbexcise.database;
    
    import android.content.Context;
    import android.database.sqlite.SQLiteDatabase;
    import android.database.sqlite.SQLiteOpenHelper;
    import android.util.Log;
    
    /**
     * Created by Administrator on 2019/6/19.
     */
    
    public class DBHelper extends SQLiteOpenHelper {
    
        public DBHelper(Context context, int version) {
            //上下文,数据库文件名,null,版本号
            super(context, "person.db", null, version);
        }
    
        /**
         * 什么时候调用?
         *      当数据库文件创建时调用
         * 在此方法中做什么?
         *      建表,初始化数据
         * @param sqLiteDatabase 是操作数据库的对象
         */
        @Override
        public void onCreate(SQLiteDatabase sqLiteDatabase) {
            Log.e("TAG", "onCreate: " );
    
            String sql = "create table person (_id integer primary key autoincrement,name varchar,age int)";
            sqLiteDatabase.execSQL(sql);
        }
    
        /**
         * 当传入的版本号大于当前数据库的版本号时调用
         * 用于更新数据库
         * @param sqLiteDatabase
         * @param i
         * @param i1
         */
        @Override
        public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1) {
            Log.d("TAG", "onUpgrade: ");
        }
    }
    

    MainActivity

    package com.example.administrator.dbexcise;
    
    import android.content.ContentValues;
    import android.content.Intent;
    import android.database.Cursor;
    import android.database.sqlite.SQLiteDatabase;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.Toast;
    
    import com.example.administrator.dbexcise.database.DBHelper;
    
    public class MainActivity extends AppCompatActivity {
    
        Button button, button2, button3, button4, button5, button6;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            button = (Button) findViewById(R.id.bt1);
            button2 = (Button) findViewById(R.id.bt2);
            button3 = (Button) findViewById(R.id.bt3);
            button4 = (Button) findViewById(R.id.bt4);
            button5 = (Button) findViewById(R.id.bt5);
            button6 = (Button) findViewById(R.id.bt6);
        }
    
        /**
         * 创建库
         *
         * @param view
         */
        public void testCreateDB(View view) {
            DBHelper dbHelper = new DBHelper(this, 1);
            //获取连接
            SQLiteDatabase sqLiteDatabase = dbHelper.getReadableDatabase();
    
            Toast.makeText(this, "创建数据库", Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 插入数据
         *
         * @param view
         */
        public void testInsertDate(View view) {
            DBHelper dbHelper = new DBHelper(this,2);
            //1.得到连接
            SQLiteDatabase sqLiteDatabase = dbHelper.getReadableDatabase();
    
            //2.执行insert
            ContentValues values = new ContentValues();
            values.put("name","Tom");
            values.put("age",21);
            //返回插入的id
            /**
             * 第一个参数:表名
             * 第二个参数:null
             * 第三个参数:传入的HashMap值
             */
            long id = sqLiteDatabase.insert("person",null,values);
    
            //3.关闭连接
            sqLiteDatabase.close();
    
            //4.提示
            Toast.makeText(this,"id= "+id,Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 删除数据
         *
         * @param view
         */
        public void testDeleteDate(View view) {
            DBHelper dbHelper = new DBHelper(this,2);
            //1.得到连接
            SQLiteDatabase sqLiteDatabase = dbHelper.getReadableDatabase();
    
            //2.执行delete
            String where = "name = ?";
            String[] value = new String[]{ "Tom" };
            //返回删除的数量
            /**
             * 第一个参数:表名
             * 第二个参数:删除的where后的语句
             * 第三个参数:? 所代表的值
             */
            int deleteCount = sqLiteDatabase.delete("person",where,value);
    
            //3.关闭连接
            sqLiteDatabase.close();
    
            //4.提示
            Toast.makeText(this,"deleteCount = "+deleteCount,Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 更新数据
         *
         * @param view
         */
        public void testUpdateDate(View view) {
            DBHelper dbHelper = new DBHelper(this,2);
            //1.得到连接
            SQLiteDatabase sqLiteDatabase = dbHelper.getReadableDatabase();
    
            //2.执行update  update person set name = "Jack",age = 20 where _id = 6
    
            /**
             * 第一个参数:表名
             * 第二个参数:更新的value
             * 第三个参数:where 后的语句
             * 第四个参数:? 所代表的值
             */
            ContentValues values = new ContentValues();
            values.put("name","Jack");
            values.put("age",20);
            int updateCount = sqLiteDatabase.update("person",values,"_id = 6",null);
    
            //3.关闭连接
            sqLiteDatabase.close();
    
            //4.提示
            Toast.makeText(this,"updateCount = "+updateCount,Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 查询数据
         *
         * @param view
         */
        public void testQueryDate(View view) {
            DBHelper dbHelper = new DBHelper(this,2);
            //1.得到连接
            SQLiteDatabase sqLiteDatabase = dbHelper.getReadableDatabase();
    
            //2.执行query select * from person
            Cursor cursor =  sqLiteDatabase.query("person",null,null,null,null,null,null);
            //得到cursor查询到的总记录数
            int count = cursor.getCount();
    
            while(cursor.moveToNext()){
                // id
                int id = cursor.getInt(0);
    
                // name
                String name = cursor.getString(1);
    
                // age
                int age = cursor.getInt(cursor.getColumnIndex("age"));
            }
    
            //3.关闭连接
            cursor.close();
            sqLiteDatabase.close();
    
            //4.提示
            Toast.makeText(this,"count = "+count,Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 事务处理
         *
         * 一个功能中对数据库进行多个操作,要就都成功要就都失败
         * 事务处理三步骤:
         * 1.   开启事务(获取连接后)
         * 2.   设置事务成功(在全部正常执行完后)
         * 3.   结束事务(finally中进行)
         *
         * @param view
         */
        public void testHandleAffair(View view) {
            SQLiteDatabase sqLiteDatabase = null;
            try {
                DBHelper dbHelper = new DBHelper(this,2);
                //1.得到连接
                sqLiteDatabase = dbHelper.getReadableDatabase();
    
                //1. 开启事务(获取连接后)
                sqLiteDatabase.beginTransaction();
    
                //2.执行update  update person set age = 20 where _id = 6
                ContentValues values = new ContentValues();
                values.put("age",20);
                int updateCount = sqLiteDatabase.update("person",values,"_id = 6",null);
    
                boolean flag = true;
                if(flag) {
                    throw new RuntimeException("出异常啦!!");
                }
    
                //执行update  update person set age = 21 where _id = 7
                values.put("age",21);
                int updateCount2 = sqLiteDatabase.update("person",values,"_id = 7",null);
    
                //2.设置事务成功(在全部正常执行完后)
                sqLiteDatabase.setTransactionSuccessful();
            }catch (Exception e) {
                Toast.makeText(this,"出异常啦!!!",Toast.LENGTH_SHORT).show();
            }finally {
                if (sqLiteDatabase!=null) {
                    //3.结束事务(finally中进行)
                    sqLiteDatabase.endTransaction();
                    //3.关闭连接
                    sqLiteDatabase.close();
                }
            }
        }
    }
    

    注意:new一个数据库对象后,一定要获取连接再进行操作。

     

    链接:https://pan.baidu.com/s/1TwNX_V0pI-yPSBFqJpm9DA 


    提取码:hnz2

    展开全文
  • 存储过程(Stored Procedure)是在大型数据库系统中,一组为了完成特定功能的SQL 语句集,它存储在数据库中,一次编译后永久有效,用户通过指定存储过程的名字并给出参数(如果该存储过程参数)来执行它。...
  • 5.10.1 操作查询之生成表查询

    千次阅读 2021-08-16 10:19:49
    操作查询用于创建新表或者对现有表中的数据进行修改。一个数据库系统经常需要进行各种数据维护。... Access提供的操作查询有以下几种类型:生成表查询、追加查询、数据查询和更新查询. 生成表查询利用一...
  • 创建 更新 接口 一直 在 LOADING 查询删除 接口 参数 输入框 爆红 创建 更新 解决方式 错误的写法 @ApiOperation(value = "创建用户基本信息", httpMethod = "POST") @ApiImplicitParams(value = ...
  • 1.4 将查询结果插入到表中 2、更新数据 3、删除数据 数据库通过插入、更新和删除等方式来改变表中的记录。插入数据是向表中插入新的记录,通过 INSERT 语句来实现。更新数据是改变表中已经存在的数据,使用UPDATE...
  • 用户数据列表 - 请求路径:users - 请求方法:get - 请求参数 | 参数名 | 参数说明 | 备注 | | -------- | ------------ | -------- | | query | 查询参数 | 可以为空 | | pagenum | 当前页码 | 不能为空 | | ...
  • 查询字段是否存在 查询course表中,存在lectures_count字段的记录信息 ...参数:ture或者false 使用update命令,删除单一字段 update命令 update命令格式: db.collection.update(criteri...
  • 前后端交互请求头响应头和提交和回执参数说明。
  • Android学习笔记----SQLiteDatabase 自带添加、删除、更新查询的操作方法:实现添加,删除,更新, 7.除了前面给大家介绍的execSQL()和rawQuery()方法, SQLiteDatabase还专门提供了对应 于添加、删除、更新、...
  • MySQL入门之创建更新、修改、复制、查看表
  • Android检查更新下载安装

    万次阅读 多人点赞 2017-09-05 15:32:00
    检查更新是任何app都会用到功能,任何一个app都不可能第一个版本就能把所有的需求都能实现,通过不断的挖掘需求迭代才能使app变的越来越好。检查更新自动下载安装分以下几个步骤: 请求服务器判断是否有最新版本...
  • odps基础积累-创建

    千次阅读 2019-09-07 12:02:07
    纯粹基础知识积累,便于后续查询,由于互联网产品更新迭代非常快,记录的知识可能只适合当下一段时间, 所以,官网www.aliyun.com有最新最权威文档. 1.概念 ODPS(Open Data Processing Service),是阿里云分析处理海量...
  • ClickHouse - 创建漂亮的 Grafana 仪表盘

    万次阅读 2019-12-29 18:54:46
    这里我们可以把 ClickHouse 参数对应的值选择自己的数据源名称(比如前面创建的 ClickHouse),然后点击 Import 完成导入。 默认使用的数据库和表为 airline.ontime,由于笔者环境为 ssb.ontime,所以需要修改模板,...
  • SQLServer之创建存储过程

    万次阅读 2018-11-01 11:18:45
    创建存储过程注意事项 在 SQL Server、 Azure SQL Database、Azure SQL 数据仓库和并行数据库中创建 Transact-SQL 或公共语言运行时 (CLR) 存储... 接受输入参数并以输出参数的格式向调用过程或批处理返回多...
  • Vue数据更新但页面没有更新的多种情况 1、Vue 无法检测实例被创建时不存在于 data 中的 变量 原因:由于 Vue 会在初始化实例时对 data中的数据执行 getter/setter 转化,所以 变量必须在 data 对象上存在才能让 Vue ...
  • 前言 因为做一个比赛的项目 ,需要用到 neo4j 数据库,所以要学习其语言cql,特来整理一下他的基本语言。 整片的语句是按照 了 Neo4j 数据库自带的示例 Movie Graph 来写的。 直接看这个博客也是没有问题的。...参数
  • Mysql系统参数查询和设置

    千次阅读 2018-10-16 11:46:04
    信息包括表类型和表的最新更新时间。 show privileges; -- 显示服务器所支持的不同权限。 show create database database_name; -- 显示create database 语句是否能够创建指定的数据库。 show create table table...
  • navicate创建mysql存储过程,同时需要对存储过程中的查询list结果集进行遍历,获取相应的结果参数执行其他的业务逻辑; 存储过程可定义事件定时器,定时执行函数,具体操作可见另一篇博文:navicate创建mysql存储...
  • (本篇正在更新中..可以关注后,持续探讨) 一.方案汇总 网上查询的很多资料,零零散散没有找到一个比较满意的方案,特地汇总一下解决方案。 目前解决方案暂定为3种 1.利用cxf动态调用webservice 2.利用axis2的...
  • MySQL视图-(视图创建,修改,删除,查看,更新数据) 视图是一种虚拟存在的表,对于使用视图的用户来说基本上是透明的。视图并不在数据库中实际存在,行和列数据来自定义视图的查询总使用的表,并且是在使用视图时...
  • 一、通过解析方法名创建查询 在执行查询时,Spring Data JPA框架会把方法名进行解析,解析到前缀比如 get、getBy、find、findBy、read、readBy时,会先把这些前缀截取掉,然后对剩下部分进行解析,剩下部分分为两...
  • NSLog(@"数据更新失败"); NSAssert(0, @"error updating :%s",errorMsg); sqlite3_finalize(stmt); sqlite3_close(database); 当然,你也可以用大家熟知的,直接把数据写在要执行的sql语句后面,如下: ...
  • elasticsearch 深入 —— Scroll滚动查询

    万次阅读 2018-09-18 09:19:03
    也可以使用一个查询字符串的参数或者在请求的body中传递。多个scroll ID 可以使用逗号分隔传入: DELETE /_search/scroll/DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAAD4WYm9laVYtZndUQlNsdDcwakFMNjU1QQ==,DnF1ZXJ5...
  • 如果当前没有事务,就以非事务方式执行 Propagation.MANDATORY:使用当前的事务,且必须在一个已有的事务中执行,如果当前不存在事务,否则抛出异常 Propagation.REQUIRES_NEW:不管是否存在事务,都创建一个新的...
  • 习题 1.存储过程的作用是什么?为什么利用存储过程可以提高数据的操作效率? 答:(1)允许模块化程序设计 ...答:可通过输入、输出参数。或者 4.存储过程的参数有几种形式? 答:有输入和输出两种。 ...
  • Kettle: 插入/更新、表输出及表输入

    千次阅读 2020-08-07 17:51:09
    依据查询关键字段,将未被发现的行记录插入到表中。 如果行记录在表中被找到,则比较需更新的字段,若更新字段不一致,则进行更新操作。 在MySQL中构建连个表personal_a和personal_b,其创建语句及原始数据如下。...
  • Sqlmap全参数详解

    万次阅读 多人点赞 2018-06-09 00:05:13
    sqlmap全参数详解 sqlmap是在sql注入中非常常用的一款工具,由于其开源性,适合从个人到企业,从学习到实战,各领域各阶段的应用,我们还可以将它改造成我们自己独有的渗透利器。这款工具中,大大小小191个参数,在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 492,890
精华内容 197,156
关键字:

创建带参数的更新查询